@mokronos/wfkit 0.1.0

package/dist/schemas.d.ts

@@ -0,0 +1,1198 @@
+import { Schema } from "effect";
+export declare const ExecutionId: Schema.brand<Schema.String, "ExecutionId">;
+export type ExecutionId = typeof ExecutionId.Type;
+export interface JsonSchema {
+    readonly type?: string | ReadonlyArray<string>;
+    readonly const?: Schema.Json;
+    readonly enum?: ReadonlyArray<Schema.Json>;
+    readonly anyOf?: ReadonlyArray<JsonSchema>;
+    readonly oneOf?: ReadonlyArray<JsonSchema>;
+    readonly items?: JsonSchema;
+    readonly properties?: {
+        readonly [key: string]: JsonSchema;
+    };
+    readonly required?: ReadonlyArray<string>;
+    readonly [key: string]: Schema.Json | JsonSchema | ReadonlyArray<Schema.Json> | ReadonlyArray<JsonSchema> | {
+        readonly [key: string]: JsonSchema;
+    } | undefined;
+}
+export declare const JsonSchema: Schema.Codec<JsonSchema>;
+export declare const decodeJsonSchema: (value: unknown) => JsonSchema;
+/** Best-effort JSON Schema for an Effect schema; undefined when the schema
+ *  has no JSON representation. */
+export declare const jsonSchemaOf: (schema: unknown) => JsonSchema | undefined;
+export declare const WorkflowEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"workflow.started">;
+    readonly workflowName: Schema.String;
+    readonly payload: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workflow.completed">;
+    readonly workflowName: Schema.String;
+    readonly result: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workflow.failed">;
+    readonly workflowName: Schema.String;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"step.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly attempt: Schema.Number;
+    readonly input: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"step.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly attempt: Schema.Number;
+    readonly result: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"step.failed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"compensation.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly result: Schema.optionalKey<Schema.Unknown>;
+    readonly input: Schema.optionalKey<Schema.Unknown>;
+    readonly reason: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"compensation.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"compensation.failed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"sleep.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly duration: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"sleep.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly duration: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"signal.waiting">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly timeout: Schema.optionalKey<Schema.Unknown>;
+    /** JSON Schema of the payload the wait expects; lets a human or agent see
+     *  what to send before delivering the signal. */
+    readonly payloadSchema: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"signal.received">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly payload: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"signal.timeout">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly timeout: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"code.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly reason: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"code.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly result: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"code.failed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"all.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly branches: Schema.Number;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"all.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly branches: Schema.Number;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"all.failed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly branches: Schema.Number;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"cancellation.received">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly compensate: Schema.Boolean;
+    readonly actor: Schema.optionalKey<Schema.String>;
+}>]>;
+export type WorkflowEvent = typeof WorkflowEvent.Type;
+export declare const isWorkflowEvent: <I>(input: I) => input is I & ({
+    readonly type: "workflow.started";
+    readonly workflowName: string;
+    readonly payload?: unknown;
+} | {
+    readonly type: "workflow.completed";
+    readonly workflowName: string;
+    readonly result?: unknown;
+} | {
+    readonly type: "workflow.failed";
+    readonly workflowName: string;
+    readonly error?: unknown;
+} | {
+    readonly type: "step.started";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly stepName: string;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly attempt: number;
+    readonly input?: unknown;
+} | {
+    readonly type: "step.completed";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly stepName: string;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly attempt: number;
+    readonly result?: unknown;
+} | {
+    readonly type: "step.failed";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly stepName: string;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly error?: unknown;
+} | {
+    readonly type: "compensation.started";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly stepName: string;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly result?: unknown;
+    readonly input?: unknown;
+    readonly reason?: unknown;
+} | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"compensation.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+}, "Type"> | {
+    readonly type: "compensation.failed";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly stepName: string;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly error?: unknown;
+} | {
+    readonly type: "sleep.started";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly name: string;
+    readonly duration?: unknown;
+} | {
+    readonly type: "sleep.completed";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly name: string;
+    readonly duration?: unknown;
+} | {
+    readonly type: "signal.waiting";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly name: string;
+    readonly payloadSchema?: JsonSchema;
+    readonly timeout?: unknown;
+} | {
+    readonly type: "signal.received";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly name: string;
+    readonly payload?: unknown;
+} | {
+    readonly type: "signal.timeout";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly name: string;
+    readonly timeout?: unknown;
+} | {
+    readonly type: "code.started";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly name: string;
+    readonly reason?: string;
+} | {
+    readonly type: "code.completed";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly name: string;
+    readonly result?: unknown;
+    readonly reason?: string;
+} | {
+    readonly type: "code.failed";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly name: string;
+    readonly error?: unknown;
+    readonly reason?: string;
+} | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"all.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly branches: Schema.Number;
+}, "Type"> | Schema.Struct.ReadonlySide<{
+    readonly type: Schema.Literal<"all.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly branches: Schema.Number;
+}, "Type"> | {
+    readonly type: "all.failed";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly invocation: number;
+    readonly activityName: string;
+    readonly name: string;
+    readonly branches: number;
+    readonly error?: unknown;
+} | {
+    readonly type: "cancellation.received";
+    readonly executionId: string & import("effect/Brand").Brand<"ExecutionId">;
+    readonly compensate: boolean;
+    readonly actor?: string;
+});
+export declare const HistoryExecutionStarted: Schema.Struct<{
+    readonly type: Schema.Literal<"execution.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly workflowName: Schema.String;
+    readonly version: Schema.Number;
+    readonly payload: Schema.optionalKey<Schema.Unknown>;
+    readonly actor: Schema.optionalKey<Schema.String>;
+}>;
+export declare const HistorySignalDelivered: Schema.Struct<{
+    readonly type: Schema.Literal<"signal.delivered">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly payload: Schema.optionalKey<Schema.Unknown>;
+    readonly actor: Schema.optionalKey<Schema.String>;
+}>;
+export declare const HistoryExecutionCancelled: Schema.Struct<{
+    readonly type: Schema.Literal<"execution.cancelled">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly compensate: Schema.Boolean;
+    readonly actor: Schema.optionalKey<Schema.String>;
+}>;
+export declare const WorkflowHistoryEvent: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"workflow.started">;
+    readonly workflowName: Schema.String;
+    readonly payload: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workflow.completed">;
+    readonly workflowName: Schema.String;
+    readonly result: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"workflow.failed">;
+    readonly workflowName: Schema.String;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"step.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly attempt: Schema.Number;
+    readonly input: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"step.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly attempt: Schema.Number;
+    readonly result: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"step.failed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"compensation.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly result: Schema.optionalKey<Schema.Unknown>;
+    readonly input: Schema.optionalKey<Schema.Unknown>;
+    readonly reason: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"compensation.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"compensation.failed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly stepName: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"sleep.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly duration: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"sleep.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly duration: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"signal.waiting">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly timeout: Schema.optionalKey<Schema.Unknown>;
+    /** JSON Schema of the payload the wait expects; lets a human or agent see
+     *  what to send before delivering the signal. */
+    readonly payloadSchema: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"signal.received">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly payload: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"signal.timeout">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly timeout: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"code.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly reason: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"code.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly result: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"code.failed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"all.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly branches: Schema.Number;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"all.completed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly branches: Schema.Number;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"all.failed">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly invocation: Schema.Number;
+    readonly activityName: Schema.String;
+    readonly branches: Schema.Number;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"cancellation.received">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly compensate: Schema.Boolean;
+    readonly actor: Schema.optionalKey<Schema.String>;
+}>]>, Schema.Struct<{
+    readonly type: Schema.Literal<"execution.started">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly workflowName: Schema.String;
+    readonly version: Schema.Number;
+    readonly payload: Schema.optionalKey<Schema.Unknown>;
+    readonly actor: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"signal.delivered">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly name: Schema.String;
+    readonly payload: Schema.optionalKey<Schema.Unknown>;
+    readonly actor: Schema.optionalKey<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"execution.cancelled">;
+    readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly compensate: Schema.Boolean;
+    readonly actor: Schema.optionalKey<Schema.String>;
+}>]>;
+export type WorkflowHistoryEvent = typeof WorkflowHistoryEvent.Type;
+export declare const WorkflowRunStatus: Schema.Literals<readonly ["running", "completed", "failed"]>;
+export type WorkflowRunStatus = typeof WorkflowRunStatus.Type;
+export declare const WorkflowArtifact: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly version: Schema.String;
+    readonly source: Schema.String;
+    readonly exportName: Schema.optionalKey<Schema.String>;
+    readonly createdAt: Schema.optionalKey<Schema.String>;
+}>;
+export type WorkflowArtifact = typeof WorkflowArtifact.Type;
+export declare const WorkflowManifestEntry: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly version: Schema.String;
+    readonly source: Schema.optionalKey<Schema.String>;
+    readonly entrypoint: Schema.optionalKey<Schema.String>;
+    readonly exportName: Schema.optionalKey<Schema.String>;
+    readonly createdAt: Schema.optionalKey<Schema.String>;
+}>;
+export type WorkflowManifestEntry = typeof WorkflowManifestEntry.Type;
+export declare const WorkflowManifest: Schema.Struct<{
+    readonly workflows: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly version: Schema.String;
+        readonly source: Schema.optionalKey<Schema.String>;
+        readonly entrypoint: Schema.optionalKey<Schema.String>;
+        readonly exportName: Schema.optionalKey<Schema.String>;
+        readonly createdAt: Schema.optionalKey<Schema.String>;
+    }>>;
+}>;
+export type WorkflowManifest = typeof WorkflowManifest.Type;
+export declare const WorkflowRunRecord: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "ExecutionId">;
+    readonly workflowId: Schema.String;
+    readonly workflowVersion: Schema.String;
+    readonly status: Schema.Literals<readonly ["running", "completed", "failed"]>;
+    readonly input: Schema.Unknown;
+    readonly result: Schema.optionalKey<Schema.Unknown>;
+    readonly error: Schema.optionalKey<Schema.Unknown>;
+    readonly startedAt: Schema.String;
+    readonly finishedAt: Schema.optionalKey<Schema.String>;
+}>;
+export type WorkflowRunRecord = typeof WorkflowRunRecord.Type;
+export declare const WorkflowRunEventRecord: Schema.Struct<{
+    readonly id: Schema.Number;
+    readonly runId: Schema.brand<Schema.String, "ExecutionId">;
+    readonly sequence: Schema.Number;
+    readonly type: Schema.String;
+    readonly event: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"workflow.started">;
+        readonly workflowName: Schema.String;
+        readonly payload: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"workflow.completed">;
+        readonly workflowName: Schema.String;
+        readonly result: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"workflow.failed">;
+        readonly workflowName: Schema.String;
+        readonly error: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"step.started">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly stepName: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly attempt: Schema.Number;
+        readonly input: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"step.completed">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly stepName: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly attempt: Schema.Number;
+        readonly result: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"step.failed">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly stepName: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly error: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"compensation.started">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly stepName: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly result: Schema.optionalKey<Schema.Unknown>;
+        readonly input: Schema.optionalKey<Schema.Unknown>;
+        readonly reason: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"compensation.completed">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly stepName: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"compensation.failed">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly stepName: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly error: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"sleep.started">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly duration: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"sleep.completed">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly duration: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"signal.waiting">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly timeout: Schema.optionalKey<Schema.Unknown>;
+        /** JSON Schema of the payload the wait expects; lets a human or agent see
+         *  what to send before delivering the signal. */
+        readonly payloadSchema: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"signal.received">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly payload: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"signal.timeout">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly timeout: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"code.started">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly reason: Schema.optionalKey<Schema.String>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"code.completed">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly reason: Schema.optionalKey<Schema.String>;
+        readonly result: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"code.failed">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly reason: Schema.optionalKey<Schema.String>;
+        readonly error: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"all.started">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly branches: Schema.Number;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"all.completed">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly branches: Schema.Number;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"all.failed">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly invocation: Schema.Number;
+        readonly activityName: Schema.String;
+        readonly branches: Schema.Number;
+        readonly error: Schema.optionalKey<Schema.Unknown>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"cancellation.received">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly compensate: Schema.Boolean;
+        readonly actor: Schema.optionalKey<Schema.String>;
+    }>]>, Schema.Struct<{
+        readonly type: Schema.Literal<"execution.started">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly workflowName: Schema.String;
+        readonly version: Schema.Number;
+        readonly payload: Schema.optionalKey<Schema.Unknown>;
+        readonly actor: Schema.optionalKey<Schema.String>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"signal.delivered">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly name: Schema.String;
+        readonly payload: Schema.optionalKey<Schema.Unknown>;
+        readonly actor: Schema.optionalKey<Schema.String>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"execution.cancelled">;
+        readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly compensate: Schema.Boolean;
+        readonly actor: Schema.optionalKey<Schema.String>;
+    }>]>;
+    readonly createdAt: Schema.String;
+}>;
+export type WorkflowRunEventRecord = typeof WorkflowRunEventRecord.Type;
+export declare const WorkflowGraphNodeKind: Schema.Literals<readonly ["step", "sleep", "signal", "now", "random", "code", "all", "start", "end", "error"]>;
+export type WorkflowGraphNodeKind = typeof WorkflowGraphNodeKind.Type;
+export declare const WorkflowGraphSchemas: Schema.Struct<{
+    readonly input: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+    readonly output: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+    readonly errors: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+}>;
+export type WorkflowGraphSchemas = typeof WorkflowGraphSchemas.Type;
+export declare const WorkflowGraphNodeSchemas: Schema.Struct<{
+    readonly input: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+    readonly output: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+    readonly errors: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+    readonly signal: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+}>;
+export type WorkflowGraphNodeSchemas = typeof WorkflowGraphNodeSchemas.Type;
+export declare const WorkflowGraphNodeMetadata: Schema.Struct<{
+    readonly activityName: Schema.optionalKey<Schema.String>;
+    readonly input: Schema.optionalKey<Schema.Unknown>;
+    readonly duration: Schema.optionalKey<Schema.Unknown>;
+    readonly timeout: Schema.optionalKey<Schema.Unknown>;
+    readonly branches: Schema.optionalKey<Schema.Number>;
+    readonly reason: Schema.optionalKey<Schema.String>;
+    readonly retry: Schema.optionalKey<Schema.Struct<{
+        readonly attempts: Schema.Number;
+        readonly backoff: Schema.Literals<readonly ["exponential", "none"]>;
+    }>>;
+    readonly concurrency: Schema.optionalKey<Schema.Struct<{
+        readonly limit: Schema.Number;
+        readonly keyed: Schema.Boolean;
+    }>>;
+    readonly compensates: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type WorkflowGraphNodeMetadata = typeof WorkflowGraphNodeMetadata.Type;
+export declare const WorkflowGraphNode: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.Literals<readonly ["step", "sleep", "signal", "now", "random", "code", "all", "start", "end", "error"]>;
+    readonly label: Schema.String;
+    readonly invocation: Schema.optionalKey<Schema.Number>;
+    readonly repeated: Schema.Boolean;
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly schemas: Schema.optionalKey<Schema.Struct<{
+        readonly input: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+        readonly output: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+        readonly errors: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+        readonly signal: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+    }>>;
+    readonly metadata: Schema.Struct<{
+        readonly activityName: Schema.optionalKey<Schema.String>;
+        readonly input: Schema.optionalKey<Schema.Unknown>;
+        readonly duration: Schema.optionalKey<Schema.Unknown>;
+        readonly timeout: Schema.optionalKey<Schema.Unknown>;
+        readonly branches: Schema.optionalKey<Schema.Number>;
+        readonly reason: Schema.optionalKey<Schema.String>;
+        readonly retry: Schema.optionalKey<Schema.Struct<{
+            readonly attempts: Schema.Number;
+            readonly backoff: Schema.Literals<readonly ["exponential", "none"]>;
+        }>>;
+        readonly concurrency: Schema.optionalKey<Schema.Struct<{
+            readonly limit: Schema.Number;
+            readonly keyed: Schema.Boolean;
+        }>>;
+        readonly compensates: Schema.optionalKey<Schema.Boolean>;
+    }>;
+}>;
+export type WorkflowGraphNode = typeof WorkflowGraphNode.Type;
+export declare const WorkflowGraphEdge: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly source: Schema.String;
+    readonly target: Schema.String;
+    readonly label: Schema.optionalKey<Schema.String>;
+}>;
+export type WorkflowGraphEdge = typeof WorkflowGraphEdge.Type;
+export declare const WorkflowGraphCall: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["step", "sleep", "signal", "now", "random", "code", "all", "start", "end", "error"]>;
+    readonly name: Schema.String;
+    readonly counter: Schema.Number;
+    readonly branches: Schema.optionalKey<Schema.Number>;
+}>;
+export declare const WorkflowGraph: Schema.Struct<{
+    readonly workflowName: Schema.String;
+    readonly version: Schema.Number;
+    readonly engineName: Schema.optionalKey<Schema.String>;
+    readonly sourceHash: Schema.optionalKey<Schema.String>;
+    readonly schemas: Schema.optionalKey<Schema.Struct<{
+        readonly input: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+        readonly output: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+        readonly errors: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+    }>>;
+    readonly nodes: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.Literals<readonly ["step", "sleep", "signal", "now", "random", "code", "all", "start", "end", "error"]>;
+        readonly label: Schema.String;
+        readonly invocation: Schema.optionalKey<Schema.Number>;
+        readonly repeated: Schema.Boolean;
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly schemas: Schema.optionalKey<Schema.Struct<{
+            readonly input: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+            readonly output: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+            readonly errors: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+            readonly signal: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+        }>>;
+        readonly metadata: Schema.Struct<{
+            readonly activityName: Schema.optionalKey<Schema.String>;
+            readonly input: Schema.optionalKey<Schema.Unknown>;
+            readonly duration: Schema.optionalKey<Schema.Unknown>;
+            readonly timeout: Schema.optionalKey<Schema.Unknown>;
+            readonly branches: Schema.optionalKey<Schema.Number>;
+            readonly reason: Schema.optionalKey<Schema.String>;
+            readonly retry: Schema.optionalKey<Schema.Struct<{
+                readonly attempts: Schema.Number;
+                readonly backoff: Schema.Literals<readonly ["exponential", "none"]>;
+            }>>;
+            readonly concurrency: Schema.optionalKey<Schema.Struct<{
+                readonly limit: Schema.Number;
+                readonly keyed: Schema.Boolean;
+            }>>;
+            readonly compensates: Schema.optionalKey<Schema.Boolean>;
+        }>;
+    }>>;
+    readonly edges: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly source: Schema.String;
+        readonly target: Schema.String;
+        readonly label: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly calls: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["step", "sleep", "signal", "now", "random", "code", "all", "start", "end", "error"]>;
+        readonly name: Schema.String;
+        readonly counter: Schema.Number;
+        readonly branches: Schema.optionalKey<Schema.Number>;
+    }>>;
+    readonly diagnostics: Schema.$Array<Schema.String>;
+}>;
+export type WorkflowGraph = typeof WorkflowGraph.Type;
+export declare const WorkflowArtifactGraph: Schema.Struct<{
+    readonly artifact: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly version: Schema.String;
+        readonly source: Schema.String;
+        readonly exportName: Schema.optionalKey<Schema.String>;
+        readonly createdAt: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly exportName: Schema.optionalKey<Schema.String>;
+    readonly graph: Schema.optionalKey<Schema.Struct<{
+        readonly workflowName: Schema.String;
+        readonly version: Schema.Number;
+        readonly engineName: Schema.optionalKey<Schema.String>;
+        readonly sourceHash: Schema.optionalKey<Schema.String>;
+        readonly schemas: Schema.optionalKey<Schema.Struct<{
+            readonly input: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+            readonly output: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+            readonly errors: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+        }>>;
+        readonly nodes: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.Literals<readonly ["step", "sleep", "signal", "now", "random", "code", "all", "start", "end", "error"]>;
+            readonly label: Schema.String;
+            readonly invocation: Schema.optionalKey<Schema.Number>;
+            readonly repeated: Schema.Boolean;
+            readonly description: Schema.optionalKey<Schema.String>;
+            readonly schemas: Schema.optionalKey<Schema.Struct<{
+                readonly input: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+                readonly output: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+                readonly errors: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+                readonly signal: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+            }>>;
+            readonly metadata: Schema.Struct<{
+                readonly activityName: Schema.optionalKey<Schema.String>;
+                readonly input: Schema.optionalKey<Schema.Unknown>;
+                readonly duration: Schema.optionalKey<Schema.Unknown>;
+                readonly timeout: Schema.optionalKey<Schema.Unknown>;
+                readonly branches: Schema.optionalKey<Schema.Number>;
+                readonly reason: Schema.optionalKey<Schema.String>;
+                readonly retry: Schema.optionalKey<Schema.Struct<{
+                    readonly attempts: Schema.Number;
+                    readonly backoff: Schema.Literals<readonly ["exponential", "none"]>;
+                }>>;
+                readonly concurrency: Schema.optionalKey<Schema.Struct<{
+                    readonly limit: Schema.Number;
+                    readonly keyed: Schema.Boolean;
+                }>>;
+                readonly compensates: Schema.optionalKey<Schema.Boolean>;
+            }>;
+        }>>;
+        readonly edges: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly source: Schema.String;
+            readonly target: Schema.String;
+            readonly label: Schema.optionalKey<Schema.String>;
+        }>>;
+        readonly calls: Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["step", "sleep", "signal", "now", "random", "code", "all", "start", "end", "error"]>;
+            readonly name: Schema.String;
+            readonly counter: Schema.Number;
+            readonly branches: Schema.optionalKey<Schema.Number>;
+        }>>;
+        readonly diagnostics: Schema.$Array<Schema.String>;
+    }>>;
+    readonly diagnostics: Schema.$Array<Schema.String>;
+}>;
+export type WorkflowArtifactGraph = typeof WorkflowArtifactGraph.Type;
+export declare const WorkflowsResponse: Schema.Struct<{
+    readonly generatedAt: Schema.String;
+    readonly workflows: Schema.$Array<Schema.Struct<{
+        readonly artifact: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly name: Schema.String;
+            readonly version: Schema.String;
+            readonly source: Schema.String;
+            readonly exportName: Schema.optionalKey<Schema.String>;
+            readonly createdAt: Schema.optionalKey<Schema.String>;
+        }>;
+        readonly exportName: Schema.optionalKey<Schema.String>;
+        readonly graph: Schema.optionalKey<Schema.Struct<{
+            readonly workflowName: Schema.String;
+            readonly version: Schema.Number;
+            readonly engineName: Schema.optionalKey<Schema.String>;
+            readonly sourceHash: Schema.optionalKey<Schema.String>;
+            readonly schemas: Schema.optionalKey<Schema.Struct<{
+                readonly input: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+                readonly output: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+                readonly errors: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+            }>>;
+            readonly nodes: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly kind: Schema.Literals<readonly ["step", "sleep", "signal", "now", "random", "code", "all", "start", "end", "error"]>;
+                readonly label: Schema.String;
+                readonly invocation: Schema.optionalKey<Schema.Number>;
+                readonly repeated: Schema.Boolean;
+                readonly description: Schema.optionalKey<Schema.String>;
+                readonly schemas: Schema.optionalKey<Schema.Struct<{
+                    readonly input: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+                    readonly output: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+                    readonly errors: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+                    readonly signal: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+                }>>;
+                readonly metadata: Schema.Struct<{
+                    readonly activityName: Schema.optionalKey<Schema.String>;
+                    readonly input: Schema.optionalKey<Schema.Unknown>;
+                    readonly duration: Schema.optionalKey<Schema.Unknown>;
+                    readonly timeout: Schema.optionalKey<Schema.Unknown>;
+                    readonly branches: Schema.optionalKey<Schema.Number>;
+                    readonly reason: Schema.optionalKey<Schema.String>;
+                    readonly retry: Schema.optionalKey<Schema.Struct<{
+                        readonly attempts: Schema.Number;
+                        readonly backoff: Schema.Literals<readonly ["exponential", "none"]>;
+                    }>>;
+                    readonly concurrency: Schema.optionalKey<Schema.Struct<{
+                        readonly limit: Schema.Number;
+                        readonly keyed: Schema.Boolean;
+                    }>>;
+                    readonly compensates: Schema.optionalKey<Schema.Boolean>;
+                }>;
+            }>>;
+            readonly edges: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly source: Schema.String;
+                readonly target: Schema.String;
+                readonly label: Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly calls: Schema.$Array<Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["step", "sleep", "signal", "now", "random", "code", "all", "start", "end", "error"]>;
+                readonly name: Schema.String;
+                readonly counter: Schema.Number;
+                readonly branches: Schema.optionalKey<Schema.Number>;
+            }>>;
+            readonly diagnostics: Schema.$Array<Schema.String>;
+        }>>;
+        readonly diagnostics: Schema.$Array<Schema.String>;
+    }>>;
+    readonly error: Schema.optionalKey<Schema.String>;
+}>;
+export type WorkflowsResponse = typeof WorkflowsResponse.Type;
+export declare const RunsResponse: Schema.Struct<{
+    readonly generatedAt: Schema.String;
+    readonly runs: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ExecutionId">;
+        readonly workflowId: Schema.String;
+        readonly workflowVersion: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "completed", "failed"]>;
+        readonly input: Schema.Unknown;
+        readonly result: Schema.optionalKey<Schema.Unknown>;
+        readonly error: Schema.optionalKey<Schema.Unknown>;
+        readonly startedAt: Schema.String;
+        readonly finishedAt: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly error: Schema.optionalKey<Schema.String>;
+}>;
+export type RunsResponse = typeof RunsResponse.Type;
+export declare const RunEventsResponse: Schema.Struct<{
+    readonly generatedAt: Schema.String;
+    readonly run: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "ExecutionId">;
+        readonly workflowId: Schema.String;
+        readonly workflowVersion: Schema.String;
+        readonly status: Schema.Literals<readonly ["running", "completed", "failed"]>;
+        readonly input: Schema.Unknown;
+        readonly result: Schema.optionalKey<Schema.Unknown>;
+        readonly error: Schema.optionalKey<Schema.Unknown>;
+        readonly startedAt: Schema.String;
+        readonly finishedAt: Schema.optionalKey<Schema.String>;
+    }>;
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Number;
+        readonly runId: Schema.brand<Schema.String, "ExecutionId">;
+        readonly sequence: Schema.Number;
+        readonly type: Schema.String;
+        readonly event: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"workflow.started">;
+            readonly workflowName: Schema.String;
+            readonly payload: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"workflow.completed">;
+            readonly workflowName: Schema.String;
+            readonly result: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"workflow.failed">;
+            readonly workflowName: Schema.String;
+            readonly error: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"step.started">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly stepName: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly attempt: Schema.Number;
+            readonly input: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"step.completed">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly stepName: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly attempt: Schema.Number;
+            readonly result: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"step.failed">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly stepName: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly error: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"compensation.started">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly stepName: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly result: Schema.optionalKey<Schema.Unknown>;
+            readonly input: Schema.optionalKey<Schema.Unknown>;
+            readonly reason: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"compensation.completed">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly stepName: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"compensation.failed">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly stepName: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly error: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"sleep.started">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly duration: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"sleep.completed">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly duration: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"signal.waiting">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly timeout: Schema.optionalKey<Schema.Unknown>;
+            /** JSON Schema of the payload the wait expects; lets a human or agent see
+             *  what to send before delivering the signal. */
+            readonly payloadSchema: Schema.optionalKey<Schema.Codec<JsonSchema, JsonSchema, never, never>>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"signal.received">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly payload: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"signal.timeout">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly timeout: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"code.started">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly reason: Schema.optionalKey<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"code.completed">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly reason: Schema.optionalKey<Schema.String>;
+            readonly result: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"code.failed">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly reason: Schema.optionalKey<Schema.String>;
+            readonly error: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"all.started">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly branches: Schema.Number;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"all.completed">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly branches: Schema.Number;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"all.failed">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly invocation: Schema.Number;
+            readonly activityName: Schema.String;
+            readonly branches: Schema.Number;
+            readonly error: Schema.optionalKey<Schema.Unknown>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"cancellation.received">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly compensate: Schema.Boolean;
+            readonly actor: Schema.optionalKey<Schema.String>;
+        }>]>, Schema.Struct<{
+            readonly type: Schema.Literal<"execution.started">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly workflowName: Schema.String;
+            readonly version: Schema.Number;
+            readonly payload: Schema.optionalKey<Schema.Unknown>;
+            readonly actor: Schema.optionalKey<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"signal.delivered">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly name: Schema.String;
+            readonly payload: Schema.optionalKey<Schema.Unknown>;
+            readonly actor: Schema.optionalKey<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"execution.cancelled">;
+            readonly executionId: Schema.brand<Schema.String, "ExecutionId">;
+            readonly compensate: Schema.Boolean;
+            readonly actor: Schema.optionalKey<Schema.String>;
+        }>]>;
+        readonly createdAt: Schema.String;
+    }>>;
+    readonly error: Schema.optionalKey<Schema.String>;
+}>;
+export type RunEventsResponse = typeof RunEventsResponse.Type;
+export declare const decodeWorkflowsResponse: (value: unknown) => WorkflowsResponse;
+export declare const decodeRunsResponse: (value: unknown) => RunsResponse;
+export declare const decodeRunEventsResponse: (value: unknown) => RunEventsResponse;
+//# sourceMappingURL=schemas.d.ts.map