@fungi.computer/braid 0.0.0-stage → 0.1.0

package/dist/schema.d.ts

@@ -0,0 +1,1183 @@
+import * as S from "effect/Schema";
+/** Same byte/depth envelope as the App API projection. */
+export declare const projectionSchema: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+export declare const portRefSchema: S.Struct<{
+    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+    readonly port: S.String;
+}>;
+export declare const valueSchema: S.Union<readonly [S.Struct<{
+    readonly literal: S.Codec<S.Json, S.Json, never, never>;
+}>, S.Struct<{
+    readonly template: S.String;
+}>]>;
+declare const fromSchema: S.Struct<{
+    readonly from: S.Struct<{
+        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+        readonly port: S.String;
+    }>;
+    readonly path: S.optionalKey<S.String>;
+}>;
+export type Mapping = typeof fromSchema.Type | typeof valueSchema.Type | {
+    readonly coalesce: readonly Mapping[];
+} | {
+    readonly object: Readonly<Record<string, Mapping>>;
+} | {
+    readonly array: readonly Mapping[];
+} | {
+    readonly each: {
+        readonly over: Mapping;
+        readonly body: Mapping;
+        readonly maxItems: number;
+    };
+};
+export declare const mappingSchema: S.Codec<Mapping>;
+export type Predicate = {
+    readonly op: "eq" | "neq" | "gt" | "lt" | "in";
+    readonly left: Mapping;
+    readonly right: Mapping;
+} | {
+    readonly op: "exists";
+    readonly value: Mapping;
+} | {
+    readonly op: "and" | "or";
+    readonly tests: readonly Predicate[];
+} | {
+    readonly op: "not";
+    readonly test: Predicate;
+};
+export declare const predicateSchema: S.Codec<Predicate>;
+/** JavaScript body and declared data only; the whole graph also bounds UTF-8 bytes. */
+export declare const codeNodeSchema: S.Struct<{
+    readonly id: S.String;
+    readonly kind: S.Literal<"code">;
+    readonly source: S.String;
+    readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+}>;
+export type CodeNode = typeof codeNodeSchema.Type;
+export declare const nodeSchema: S.Union<readonly [S.Struct<{
+    readonly id: S.String;
+    readonly kind: S.Literal<"code">;
+    readonly source: S.String;
+    readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+}>, S.Struct<{
+    readonly id: S.String;
+    readonly kind: S.Literal<"app">;
+    readonly app: S.String;
+    readonly method: S.String;
+    readonly methodDigest: S.String;
+    readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+    readonly gitAccess: S.optionalKey<S.declare<{
+        binding: string;
+        repository: string;
+        branches: string[];
+    } | {
+        binding: string;
+        repository: string;
+        access: "read";
+    }, {
+        binding: string;
+        repository: string;
+        branches: string[];
+    } | {
+        binding: string;
+        repository: string;
+        access: "read";
+    }>>;
+    readonly retry: S.optionalKey<S.Struct<{
+        readonly attempts: S.Number;
+    }>>;
+}>, S.Struct<{
+    readonly id: S.String;
+    readonly kind: S.Literal<"review">;
+    readonly title: S.String;
+    /**
+     * One plain line under the title saying where the run is, such as
+     * `Beat {item} of {items} · try {try} of {tries}`. The placeholders are
+     * filled from the loops around the review (see `fillReviewText`).
+     */
+    readonly detail: S.optionalKey<S.String>;
+    readonly show: S.$Array<S.Struct<{
+        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+        readonly port: S.String;
+    }>>;
+    readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+    readonly timeout: S.Number;
+    /**
+     * Named outcomes a reviewer picks from; each is an output port carrying
+     * the shown item. Without choices the review approves or rejects. A
+     * choice's `description` says in plain words what picking it does, with
+     * the same placeholders as `detail`.
+     */
+    readonly choices: S.optionalKey<S.$Array<S.Struct<{
+        readonly id: S.String;
+        readonly label: S.String;
+        readonly description: S.optionalKey<S.String>;
+    }>>>;
+}>, S.Struct<{
+    readonly id: S.String;
+    readonly kind: S.Literal<"condition">;
+    readonly test: S.Codec<Predicate, Predicate, never, never>;
+}>, S.Struct<{
+    readonly id: S.String;
+    readonly kind: S.Literal<"map">;
+    readonly over: S.Struct<{
+        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+        readonly port: S.String;
+    }>;
+    readonly body: S.String;
+    readonly concurrency: S.Number;
+    readonly maxItems: S.Number;
+}>, S.Struct<{
+    readonly id: S.String;
+    readonly kind: S.Literal<"repeat">;
+    readonly body: S.String;
+    readonly maxRounds: S.Number;
+    /** The predicate reads the completed body's output through $input. */
+    readonly until: S.Codec<Predicate, Predicate, never, never>;
+}>, S.Struct<{
+    readonly id: S.String;
+    readonly kind: S.Literal<"wait">;
+    readonly for: S.Number;
+}>, S.Struct<{
+    readonly id: S.String;
+    readonly kind: S.Literal<"transform">;
+    readonly fields: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+}>]>;
+export declare const edgeSchema: S.Struct<{
+    readonly from: S.Struct<{
+        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+        readonly port: S.String;
+    }>;
+    readonly to: S.Struct<{
+        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+        readonly port: S.String;
+    }>;
+}>;
+/**
+ * Ports of the event a trigger receives. Inside a trigger, `$input` names this
+ * event, not the run input: the trigger maps it onto the run's `$input`. Every
+ * port is the same on a redelivery of the same event, so a redelivery maps to
+ * the same run input and replays instead of conflicting.
+ */
+export declare const TRIGGER_EVENT_PORTS: {
+    readonly webhook: readonly ["body", "eventId", "headers"];
+    readonly schedule: readonly ["scheduledAt", "eventId"];
+    readonly event: readonly ["payload", "eventId"];
+};
+export declare const graphSchema: S.Struct<{
+    readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"code">;
+        readonly source: S.String;
+        readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"app">;
+        readonly app: S.String;
+        readonly method: S.String;
+        readonly methodDigest: S.String;
+        readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+        readonly gitAccess: S.optionalKey<S.declare<{
+            binding: string;
+            repository: string;
+            branches: string[];
+        } | {
+            binding: string;
+            repository: string;
+            access: "read";
+        }, {
+            binding: string;
+            repository: string;
+            branches: string[];
+        } | {
+            binding: string;
+            repository: string;
+            access: "read";
+        }>>;
+        readonly retry: S.optionalKey<S.Struct<{
+            readonly attempts: S.Number;
+        }>>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"review">;
+        readonly title: S.String;
+        /**
+         * One plain line under the title saying where the run is, such as
+         * `Beat {item} of {items} · try {try} of {tries}`. The placeholders are
+         * filled from the loops around the review (see `fillReviewText`).
+         */
+        readonly detail: S.optionalKey<S.String>;
+        readonly show: S.$Array<S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>>;
+        readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+        readonly timeout: S.Number;
+        /**
+         * Named outcomes a reviewer picks from; each is an output port carrying
+         * the shown item. Without choices the review approves or rejects. A
+         * choice's `description` says in plain words what picking it does, with
+         * the same placeholders as `detail`.
+         */
+        readonly choices: S.optionalKey<S.$Array<S.Struct<{
+            readonly id: S.String;
+            readonly label: S.String;
+            readonly description: S.optionalKey<S.String>;
+        }>>>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"condition">;
+        readonly test: S.Codec<Predicate, Predicate, never, never>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"map">;
+        readonly over: S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>;
+        readonly body: S.String;
+        readonly concurrency: S.Number;
+        readonly maxItems: S.Number;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"repeat">;
+        readonly body: S.String;
+        readonly maxRounds: S.Number;
+        /** The predicate reads the completed body's output through $input. */
+        readonly until: S.Codec<Predicate, Predicate, never, never>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"wait">;
+        readonly for: S.Number;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"transform">;
+        readonly fields: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+    }>]>>;
+    readonly edges: S.$Array<S.Struct<{
+        readonly from: S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>;
+        readonly to: S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>;
+    }>>;
+    readonly output: S.$Record<S.String, S.Struct<{
+        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+        readonly port: S.String;
+    }>>;
+}>;
+export declare const workflowDefinitionSchema: S.Struct<{
+    readonly format: S.Literal<"fungi.workflow/v1">;
+    readonly title: S.String;
+    readonly description: S.optionalKey<S.String>;
+    readonly apps: S.$Record<S.String, S.Struct<{
+        readonly appId: S.String;
+        readonly role: S.optionalKey<S.String>;
+    }>>;
+    readonly subgraphs: S.optionalKey<S.$Record<S.String, S.Struct<{
+        readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"code">;
+            readonly source: S.String;
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"app">;
+            readonly app: S.String;
+            readonly method: S.String;
+            readonly methodDigest: S.String;
+            readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+            readonly gitAccess: S.optionalKey<S.declare<{
+                binding: string;
+                repository: string;
+                branches: string[];
+            } | {
+                binding: string;
+                repository: string;
+                access: "read";
+            }, {
+                binding: string;
+                repository: string;
+                branches: string[];
+            } | {
+                binding: string;
+                repository: string;
+                access: "read";
+            }>>;
+            readonly retry: S.optionalKey<S.Struct<{
+                readonly attempts: S.Number;
+            }>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"review">;
+            readonly title: S.String;
+            /**
+             * One plain line under the title saying where the run is, such as
+             * `Beat {item} of {items} · try {try} of {tries}`. The placeholders are
+             * filled from the loops around the review (see `fillReviewText`).
+             */
+            readonly detail: S.optionalKey<S.String>;
+            readonly show: S.$Array<S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>>;
+            readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+            readonly timeout: S.Number;
+            /**
+             * Named outcomes a reviewer picks from; each is an output port carrying
+             * the shown item. Without choices the review approves or rejects. A
+             * choice's `description` says in plain words what picking it does, with
+             * the same placeholders as `detail`.
+             */
+            readonly choices: S.optionalKey<S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly label: S.String;
+                readonly description: S.optionalKey<S.String>;
+            }>>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"condition">;
+            readonly test: S.Codec<Predicate, Predicate, never, never>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"map">;
+            readonly over: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+            readonly body: S.String;
+            readonly concurrency: S.Number;
+            readonly maxItems: S.Number;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"repeat">;
+            readonly body: S.String;
+            readonly maxRounds: S.Number;
+            /** The predicate reads the completed body's output through $input. */
+            readonly until: S.Codec<Predicate, Predicate, never, never>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"wait">;
+            readonly for: S.Number;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"transform">;
+            readonly fields: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+        }>]>>;
+        readonly edges: S.$Array<S.Struct<{
+            readonly from: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+            readonly to: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+        }>>;
+        readonly output: S.$Record<S.String, S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>>;
+    }>>>;
+    readonly triggers: S.optionalKey<S.$Array<S.Union<readonly [S.Struct<{
+        readonly id: S.String;
+        readonly on: S.Literal<"webhook">;
+        readonly title: S.optionalKey<S.String>;
+        readonly when: S.optionalKey<S.Codec<Predicate, Predicate, never, never>>;
+        readonly input: S.optionalKey<S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly on: S.Literal<"schedule">;
+        readonly title: S.optionalKey<S.String>;
+        readonly cron: S.Struct<{
+            readonly expression: S.String;
+            readonly timeZone: S.String;
+        }>;
+        readonly input: S.optionalKey<S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly on: S.Literal<"event">;
+        readonly title: S.optionalKey<S.String>;
+        readonly app: S.String;
+        readonly event: S.String;
+        readonly eventDigest: S.String;
+        readonly when: S.optionalKey<S.Codec<Predicate, Predicate, never, never>>;
+        readonly input: S.optionalKey<S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>>;
+        /**
+         * The one repository, in the event App's own Git namespace, this event is
+         * about. A node's `gitAccess` names it as `$trigger.repository`.
+         */
+        readonly repository: S.optionalKey<S.Codec<Mapping, Mapping, never, never>>;
+    }>]>>>;
+    readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"code">;
+        readonly source: S.String;
+        readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"app">;
+        readonly app: S.String;
+        readonly method: S.String;
+        readonly methodDigest: S.String;
+        readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+        readonly gitAccess: S.optionalKey<S.declare<{
+            binding: string;
+            repository: string;
+            branches: string[];
+        } | {
+            binding: string;
+            repository: string;
+            access: "read";
+        }, {
+            binding: string;
+            repository: string;
+            branches: string[];
+        } | {
+            binding: string;
+            repository: string;
+            access: "read";
+        }>>;
+        readonly retry: S.optionalKey<S.Struct<{
+            readonly attempts: S.Number;
+        }>>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"review">;
+        readonly title: S.String;
+        /**
+         * One plain line under the title saying where the run is, such as
+         * `Beat {item} of {items} · try {try} of {tries}`. The placeholders are
+         * filled from the loops around the review (see `fillReviewText`).
+         */
+        readonly detail: S.optionalKey<S.String>;
+        readonly show: S.$Array<S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>>;
+        readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+        readonly timeout: S.Number;
+        /**
+         * Named outcomes a reviewer picks from; each is an output port carrying
+         * the shown item. Without choices the review approves or rejects. A
+         * choice's `description` says in plain words what picking it does, with
+         * the same placeholders as `detail`.
+         */
+        readonly choices: S.optionalKey<S.$Array<S.Struct<{
+            readonly id: S.String;
+            readonly label: S.String;
+            readonly description: S.optionalKey<S.String>;
+        }>>>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"condition">;
+        readonly test: S.Codec<Predicate, Predicate, never, never>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"map">;
+        readonly over: S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>;
+        readonly body: S.String;
+        readonly concurrency: S.Number;
+        readonly maxItems: S.Number;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"repeat">;
+        readonly body: S.String;
+        readonly maxRounds: S.Number;
+        /** The predicate reads the completed body's output through $input. */
+        readonly until: S.Codec<Predicate, Predicate, never, never>;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"wait">;
+        readonly for: S.Number;
+    }>, S.Struct<{
+        readonly id: S.String;
+        readonly kind: S.Literal<"transform">;
+        readonly fields: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+    }>]>>;
+    readonly edges: S.$Array<S.Struct<{
+        readonly from: S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>;
+        readonly to: S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>;
+    }>>;
+    readonly output: S.$Record<S.String, S.Struct<{
+        readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+        readonly port: S.String;
+    }>>;
+}>;
+/** Structural App API method shape from T1; digests are supplied by its catalog owner. */
+export declare const methodSchema: S.Struct<{
+    /** This method may yield Agar Pending before its completed output. */
+    readonly pending: S.optionalKey<S.Literal<true>>;
+    readonly description: S.String;
+    readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    readonly effect: S.Literals<readonly ["read", "write", "external"]>;
+    readonly approval: S.Literals<readonly ["none", "queue", "simulate"]>;
+    readonly requires: S.$Array<S.String>;
+}>;
+export declare const eventSchema: S.Struct<{
+    readonly description: S.String;
+    readonly payload: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+}>;
+export declare const catalogSchema: S.$Record<S.String, S.Struct<{
+    readonly methods: S.$Record<S.String, S.Struct<{
+        readonly digest: S.String;
+        /** This method may yield Agar Pending before its completed output. */
+        readonly pending: S.optionalKey<S.Literal<true>>;
+        readonly description: S.String;
+        readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly effect: S.Literals<readonly ["read", "write", "external"]>;
+        readonly approval: S.Literals<readonly ["none", "queue", "simulate"]>;
+        readonly requires: S.$Array<S.String>;
+    }>>;
+    readonly events: S.optionalKey<S.$Record<S.String, S.Struct<{
+        readonly digest: S.String;
+        readonly description: S.String;
+        readonly payload: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+    }>>>;
+}>>;
+export declare const bindingsSchema: S.$Record<S.String, S.declare<{
+    kind: "team-source";
+} | {
+    appId: string;
+    installationId: string;
+}, {
+    kind: "team-source";
+} | {
+    appId: string;
+    installationId: string;
+}>>;
+export type WorkflowDefinition = typeof workflowDefinitionSchema.Type;
+export type Graph = typeof graphSchema.Type;
+export type Node = typeof nodeSchema.Type;
+export type PortRef = typeof portRefSchema.Type;
+export type Json = S.Json;
+export type JsonSchemaProjection = typeof projectionSchema.Type;
+export type Catalog = typeof catalogSchema.Type;
+export type Bindings = typeof bindingsSchema.Type;
+export type Method = typeof methodSchema.Type;
+export declare const planContentSchema: S.Struct<{
+    readonly definition: S.Struct<{
+        readonly format: S.Literal<"fungi.workflow/v1">;
+        readonly title: S.String;
+        readonly description: S.optionalKey<S.String>;
+        readonly apps: S.$Record<S.String, S.Struct<{
+            readonly appId: S.String;
+            readonly role: S.optionalKey<S.String>;
+        }>>;
+        readonly subgraphs: S.optionalKey<S.$Record<S.String, S.Struct<{
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"code">;
+                readonly source: S.String;
+                readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"app">;
+                readonly app: S.String;
+                readonly method: S.String;
+                readonly methodDigest: S.String;
+                readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+                readonly gitAccess: S.optionalKey<S.declare<{
+                    binding: string;
+                    repository: string;
+                    branches: string[];
+                } | {
+                    binding: string;
+                    repository: string;
+                    access: "read";
+                }, {
+                    binding: string;
+                    repository: string;
+                    branches: string[];
+                } | {
+                    binding: string;
+                    repository: string;
+                    access: "read";
+                }>>;
+                readonly retry: S.optionalKey<S.Struct<{
+                    readonly attempts: S.Number;
+                }>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"review">;
+                readonly title: S.String;
+                /**
+                 * One plain line under the title saying where the run is, such as
+                 * `Beat {item} of {items} · try {try} of {tries}`. The placeholders are
+                 * filled from the loops around the review (see `fillReviewText`).
+                 */
+                readonly detail: S.optionalKey<S.String>;
+                readonly show: S.$Array<S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>>;
+                readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+                readonly timeout: S.Number;
+                /**
+                 * Named outcomes a reviewer picks from; each is an output port carrying
+                 * the shown item. Without choices the review approves or rejects. A
+                 * choice's `description` says in plain words what picking it does, with
+                 * the same placeholders as `detail`.
+                 */
+                readonly choices: S.optionalKey<S.$Array<S.Struct<{
+                    readonly id: S.String;
+                    readonly label: S.String;
+                    readonly description: S.optionalKey<S.String>;
+                }>>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"condition">;
+                readonly test: S.Codec<Predicate, Predicate, never, never>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"map">;
+                readonly over: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+                readonly body: S.String;
+                readonly concurrency: S.Number;
+                readonly maxItems: S.Number;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"repeat">;
+                readonly body: S.String;
+                readonly maxRounds: S.Number;
+                /** The predicate reads the completed body's output through $input. */
+                readonly until: S.Codec<Predicate, Predicate, never, never>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"wait">;
+                readonly for: S.Number;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"transform">;
+                readonly fields: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+            }>]>>;
+            readonly edges: S.$Array<S.Struct<{
+                readonly from: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+                readonly to: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+            }>>;
+            readonly output: S.$Record<S.String, S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>>;
+        }>>>;
+        readonly triggers: S.optionalKey<S.$Array<S.Union<readonly [S.Struct<{
+            readonly id: S.String;
+            readonly on: S.Literal<"webhook">;
+            readonly title: S.optionalKey<S.String>;
+            readonly when: S.optionalKey<S.Codec<Predicate, Predicate, never, never>>;
+            readonly input: S.optionalKey<S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly on: S.Literal<"schedule">;
+            readonly title: S.optionalKey<S.String>;
+            readonly cron: S.Struct<{
+                readonly expression: S.String;
+                readonly timeZone: S.String;
+            }>;
+            readonly input: S.optionalKey<S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly on: S.Literal<"event">;
+            readonly title: S.optionalKey<S.String>;
+            readonly app: S.String;
+            readonly event: S.String;
+            readonly eventDigest: S.String;
+            readonly when: S.optionalKey<S.Codec<Predicate, Predicate, never, never>>;
+            readonly input: S.optionalKey<S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>>;
+            /**
+             * The one repository, in the event App's own Git namespace, this event is
+             * about. A node's `gitAccess` names it as `$trigger.repository`.
+             */
+            readonly repository: S.optionalKey<S.Codec<Mapping, Mapping, never, never>>;
+        }>]>>>;
+        readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"code">;
+            readonly source: S.String;
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"app">;
+            readonly app: S.String;
+            readonly method: S.String;
+            readonly methodDigest: S.String;
+            readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+            readonly gitAccess: S.optionalKey<S.declare<{
+                binding: string;
+                repository: string;
+                branches: string[];
+            } | {
+                binding: string;
+                repository: string;
+                access: "read";
+            }, {
+                binding: string;
+                repository: string;
+                branches: string[];
+            } | {
+                binding: string;
+                repository: string;
+                access: "read";
+            }>>;
+            readonly retry: S.optionalKey<S.Struct<{
+                readonly attempts: S.Number;
+            }>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"review">;
+            readonly title: S.String;
+            /**
+             * One plain line under the title saying where the run is, such as
+             * `Beat {item} of {items} · try {try} of {tries}`. The placeholders are
+             * filled from the loops around the review (see `fillReviewText`).
+             */
+            readonly detail: S.optionalKey<S.String>;
+            readonly show: S.$Array<S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>>;
+            readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+            readonly timeout: S.Number;
+            /**
+             * Named outcomes a reviewer picks from; each is an output port carrying
+             * the shown item. Without choices the review approves or rejects. A
+             * choice's `description` says in plain words what picking it does, with
+             * the same placeholders as `detail`.
+             */
+            readonly choices: S.optionalKey<S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly label: S.String;
+                readonly description: S.optionalKey<S.String>;
+            }>>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"condition">;
+            readonly test: S.Codec<Predicate, Predicate, never, never>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"map">;
+            readonly over: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+            readonly body: S.String;
+            readonly concurrency: S.Number;
+            readonly maxItems: S.Number;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"repeat">;
+            readonly body: S.String;
+            readonly maxRounds: S.Number;
+            /** The predicate reads the completed body's output through $input. */
+            readonly until: S.Codec<Predicate, Predicate, never, never>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"wait">;
+            readonly for: S.Number;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"transform">;
+            readonly fields: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+        }>]>>;
+        readonly edges: S.$Array<S.Struct<{
+            readonly from: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+            readonly to: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+        }>>;
+        readonly output: S.$Record<S.String, S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>>;
+    }>;
+    readonly catalog: S.$Record<S.String, S.Struct<{
+        readonly methods: S.$Record<S.String, S.Struct<{
+            readonly digest: S.String;
+            /** This method may yield Agar Pending before its completed output. */
+            readonly pending: S.optionalKey<S.Literal<true>>;
+            readonly description: S.String;
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly effect: S.Literals<readonly ["read", "write", "external"]>;
+            readonly approval: S.Literals<readonly ["none", "queue", "simulate"]>;
+            readonly requires: S.$Array<S.String>;
+        }>>;
+        readonly events: S.optionalKey<S.$Record<S.String, S.Struct<{
+            readonly digest: S.String;
+            readonly description: S.String;
+            readonly payload: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        }>>>;
+    }>>;
+    readonly bindings: S.$Record<S.String, S.declare<{
+        kind: "team-source";
+    } | {
+        appId: string;
+        installationId: string;
+    }, {
+        kind: "team-source";
+    } | {
+        appId: string;
+        installationId: string;
+    }>>;
+    readonly estimatedSteps: S.Number;
+    readonly requiredBindings: S.$Array<S.Struct<{
+        /** This method may yield Agar Pending before its completed output. */
+        readonly pending: S.optionalKey<S.Literal<true>>;
+        readonly description: S.String;
+        readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly effect: S.Literals<readonly ["read", "write", "external"]>;
+        readonly approval: S.Literals<readonly ["none", "queue", "simulate"]>;
+        readonly requires: S.$Array<S.String>;
+        readonly app: S.String;
+        readonly installationId: S.String;
+        readonly method: S.String;
+    }>>;
+}>;
+export declare const executionPlanSchema: S.Struct<{
+    readonly planDigest: S.String;
+    readonly definition: S.Struct<{
+        readonly format: S.Literal<"fungi.workflow/v1">;
+        readonly title: S.String;
+        readonly description: S.optionalKey<S.String>;
+        readonly apps: S.$Record<S.String, S.Struct<{
+            readonly appId: S.String;
+            readonly role: S.optionalKey<S.String>;
+        }>>;
+        readonly subgraphs: S.optionalKey<S.$Record<S.String, S.Struct<{
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"code">;
+                readonly source: S.String;
+                readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+                readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"app">;
+                readonly app: S.String;
+                readonly method: S.String;
+                readonly methodDigest: S.String;
+                readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+                readonly gitAccess: S.optionalKey<S.declare<{
+                    binding: string;
+                    repository: string;
+                    branches: string[];
+                } | {
+                    binding: string;
+                    repository: string;
+                    access: "read";
+                }, {
+                    binding: string;
+                    repository: string;
+                    branches: string[];
+                } | {
+                    binding: string;
+                    repository: string;
+                    access: "read";
+                }>>;
+                readonly retry: S.optionalKey<S.Struct<{
+                    readonly attempts: S.Number;
+                }>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"review">;
+                readonly title: S.String;
+                /**
+                 * One plain line under the title saying where the run is, such as
+                 * `Beat {item} of {items} · try {try} of {tries}`. The placeholders are
+                 * filled from the loops around the review (see `fillReviewText`).
+                 */
+                readonly detail: S.optionalKey<S.String>;
+                readonly show: S.$Array<S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>>;
+                readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+                readonly timeout: S.Number;
+                /**
+                 * Named outcomes a reviewer picks from; each is an output port carrying
+                 * the shown item. Without choices the review approves or rejects. A
+                 * choice's `description` says in plain words what picking it does, with
+                 * the same placeholders as `detail`.
+                 */
+                readonly choices: S.optionalKey<S.$Array<S.Struct<{
+                    readonly id: S.String;
+                    readonly label: S.String;
+                    readonly description: S.optionalKey<S.String>;
+                }>>>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"condition">;
+                readonly test: S.Codec<Predicate, Predicate, never, never>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"map">;
+                readonly over: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+                readonly body: S.String;
+                readonly concurrency: S.Number;
+                readonly maxItems: S.Number;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"repeat">;
+                readonly body: S.String;
+                readonly maxRounds: S.Number;
+                /** The predicate reads the completed body's output through $input. */
+                readonly until: S.Codec<Predicate, Predicate, never, never>;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"wait">;
+                readonly for: S.Number;
+            }>, S.Struct<{
+                readonly id: S.String;
+                readonly kind: S.Literal<"transform">;
+                readonly fields: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+            }>]>>;
+            readonly edges: S.$Array<S.Struct<{
+                readonly from: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+                readonly to: S.Struct<{
+                    readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                    readonly port: S.String;
+                }>;
+            }>>;
+            readonly output: S.$Record<S.String, S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>>;
+        }>>>;
+        readonly triggers: S.optionalKey<S.$Array<S.Union<readonly [S.Struct<{
+            readonly id: S.String;
+            readonly on: S.Literal<"webhook">;
+            readonly title: S.optionalKey<S.String>;
+            readonly when: S.optionalKey<S.Codec<Predicate, Predicate, never, never>>;
+            readonly input: S.optionalKey<S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly on: S.Literal<"schedule">;
+            readonly title: S.optionalKey<S.String>;
+            readonly cron: S.Struct<{
+                readonly expression: S.String;
+                readonly timeZone: S.String;
+            }>;
+            readonly input: S.optionalKey<S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly on: S.Literal<"event">;
+            readonly title: S.optionalKey<S.String>;
+            readonly app: S.String;
+            readonly event: S.String;
+            readonly eventDigest: S.String;
+            readonly when: S.optionalKey<S.Codec<Predicate, Predicate, never, never>>;
+            readonly input: S.optionalKey<S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>>;
+            /**
+             * The one repository, in the event App's own Git namespace, this event is
+             * about. A node's `gitAccess` names it as `$trigger.repository`.
+             */
+            readonly repository: S.optionalKey<S.Codec<Mapping, Mapping, never, never>>;
+        }>]>>>;
+        readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly nodes: S.$Array<S.Union<readonly [S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"code">;
+            readonly source: S.String;
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"app">;
+            readonly app: S.String;
+            readonly method: S.String;
+            readonly methodDigest: S.String;
+            readonly values: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+            readonly gitAccess: S.optionalKey<S.declare<{
+                binding: string;
+                repository: string;
+                branches: string[];
+            } | {
+                binding: string;
+                repository: string;
+                access: "read";
+            }, {
+                binding: string;
+                repository: string;
+                branches: string[];
+            } | {
+                binding: string;
+                repository: string;
+                access: "read";
+            }>>;
+            readonly retry: S.optionalKey<S.Struct<{
+                readonly attempts: S.Number;
+            }>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"review">;
+            readonly title: S.String;
+            /**
+             * One plain line under the title saying where the run is, such as
+             * `Beat {item} of {items} · try {try} of {tries}`. The placeholders are
+             * filled from the loops around the review (see `fillReviewText`).
+             */
+            readonly detail: S.optionalKey<S.String>;
+            readonly show: S.$Array<S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>>;
+            readonly reviewers: S.Literals<readonly ["runner", "owners"]>;
+            readonly timeout: S.Number;
+            /**
+             * Named outcomes a reviewer picks from; each is an output port carrying
+             * the shown item. Without choices the review approves or rejects. A
+             * choice's `description` says in plain words what picking it does, with
+             * the same placeholders as `detail`.
+             */
+            readonly choices: S.optionalKey<S.$Array<S.Struct<{
+                readonly id: S.String;
+                readonly label: S.String;
+                readonly description: S.optionalKey<S.String>;
+            }>>>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"condition">;
+            readonly test: S.Codec<Predicate, Predicate, never, never>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"map">;
+            readonly over: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+            readonly body: S.String;
+            readonly concurrency: S.Number;
+            readonly maxItems: S.Number;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"repeat">;
+            readonly body: S.String;
+            readonly maxRounds: S.Number;
+            /** The predicate reads the completed body's output through $input. */
+            readonly until: S.Codec<Predicate, Predicate, never, never>;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"wait">;
+            readonly for: S.Number;
+        }>, S.Struct<{
+            readonly id: S.String;
+            readonly kind: S.Literal<"transform">;
+            readonly fields: S.$Record<S.String, S.Codec<Mapping, Mapping, never, never>>;
+        }>]>>;
+        readonly edges: S.$Array<S.Struct<{
+            readonly from: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+            readonly to: S.Struct<{
+                readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+                readonly port: S.String;
+            }>;
+        }>>;
+        readonly output: S.$Record<S.String, S.Struct<{
+            readonly node: S.Union<readonly [S.String, S.Literals<readonly ["$input", "$item"]>]>;
+            readonly port: S.String;
+        }>>;
+    }>;
+    readonly catalog: S.$Record<S.String, S.Struct<{
+        readonly methods: S.$Record<S.String, S.Struct<{
+            readonly digest: S.String;
+            /** This method may yield Agar Pending before its completed output. */
+            readonly pending: S.optionalKey<S.Literal<true>>;
+            readonly description: S.String;
+            readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+            readonly effect: S.Literals<readonly ["read", "write", "external"]>;
+            readonly approval: S.Literals<readonly ["none", "queue", "simulate"]>;
+            readonly requires: S.$Array<S.String>;
+        }>>;
+        readonly events: S.optionalKey<S.$Record<S.String, S.Struct<{
+            readonly digest: S.String;
+            readonly description: S.String;
+            readonly payload: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        }>>>;
+    }>>;
+    readonly bindings: S.$Record<S.String, S.declare<{
+        kind: "team-source";
+    } | {
+        appId: string;
+        installationId: string;
+    }, {
+        kind: "team-source";
+    } | {
+        appId: string;
+        installationId: string;
+    }>>;
+    readonly estimatedSteps: S.Number;
+    readonly requiredBindings: S.$Array<S.Struct<{
+        /** This method may yield Agar Pending before its completed output. */
+        readonly pending: S.optionalKey<S.Literal<true>>;
+        readonly description: S.String;
+        readonly input: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly output: S.$Record<S.String, S.Codec<S.Json, S.Json, never, never>>;
+        readonly effect: S.Literals<readonly ["read", "write", "external"]>;
+        readonly approval: S.Literals<readonly ["none", "queue", "simulate"]>;
+        readonly requires: S.$Array<S.String>;
+        readonly app: S.String;
+        readonly installationId: S.String;
+        readonly method: S.String;
+    }>>;
+}>;
+export type ExecutionPlan = typeof executionPlanSchema.Type;
+export {};