@opencode/core 0.0.0-reserved → 2.0.0

package/dist/types/form.d.ts

@@ -0,0 +1,449 @@
+export * as Form from "./form.js";
+import { Form } from "@opencode/schema/form";
+import { Context, Effect, Layer, Schema } from "effect";
+import { Bus } from "./bus.js";
+export declare const ID: Schema.brand<Schema.String, "Form.ID"> & {
+    create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Info: Schema.Struct<{
+    readonly fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"string">;
+        readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
+        readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly maxLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly pattern: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly options: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>>, never, never>;
+        readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"number">;
+        readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"integer">;
+        readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"boolean">;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"multiselect">;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly value: Schema.String;
+            readonly label: Schema.String;
+            readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>>;
+        readonly minItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        readonly key: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+            readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+        }>>>, never, never>;
+    }>, Schema.Struct<{
+        readonly key: Schema.String;
+        readonly type: Schema.Literal<"external">;
+        readonly url: Schema.String;
+        readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>]>>;
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+    readonly sessionID: Schema.String;
+    readonly title: Schema.String;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>;
+export type Info = typeof Info.Type;
+export declare const Field: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"string">;
+    readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
+    readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly maxLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly pattern: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly options: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, never, never>;
+    readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"number">;
+    readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"integer">;
+    readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"multiselect">;
+    readonly options: Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>;
+    readonly minItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly key: Schema.String;
+    readonly type: Schema.Literal<"external">;
+    readonly url: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>]>;
+export type Field = Form.Field;
+export declare const Fields: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"string">;
+    readonly format: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>>, Schema.optionalKey<Schema.Literals<readonly ["email", "uri", "date", "date-time"]>>, never, never>;
+    readonly minLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly maxLength: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly pattern: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly options: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, never, never>;
+    readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"number">;
+    readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"integer">;
+    readonly minimum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly maximum: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"boolean">;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"multiselect">;
+    readonly options: Schema.$Array<Schema.Struct<{
+        readonly value: Schema.String;
+        readonly label: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>;
+    readonly minItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly maxItems: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly key: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly required: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+        readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+    }>>>, never, never>;
+}>, Schema.Struct<{
+    readonly key: Schema.String;
+    readonly type: Schema.Literal<"external">;
+    readonly url: Schema.String;
+    readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>]>>;
+export type Fields = Form.Fields;
+export declare const When: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly op: Schema.Literals<readonly ["eq", "neq"]>;
+    readonly value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>;
+}>;
+export type When = Form.When;
+export declare const State: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"pending">;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"answered">;
+    readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"cancelled">;
+}>]>;
+export type State = typeof State.Type;
+export type TerminalState = Exclude<State, {
+    readonly status: "pending";
+}>;
+export declare const Answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
+export type Answer = typeof Answer.Type;
+export declare const Reply: Schema.Struct<{
+    readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
+}>;
+export type Reply = typeof Reply.Type;
+export { Event } from "@opencode/schema/form";
+declare const NotFoundError_base: Schema.Class<NotFoundError, Schema.TaggedStruct<"Form.NotFoundError", {
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class NotFoundError extends NotFoundError_base {
+    get message(): string;
+}
+declare const AlreadySettledError_base: Schema.Class<AlreadySettledError, Schema.TaggedStruct<"Form.AlreadySettledError", {
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class AlreadySettledError extends AlreadySettledError_base {
+    get message(): string;
+}
+declare const AlreadyExistsError_base: Schema.Class<AlreadyExistsError, Schema.TaggedStruct<"Form.AlreadyExistsError", {
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+}>, import("effect/Cause").YieldableError>;
+export declare class AlreadyExistsError extends AlreadyExistsError_base {
+    get message(): string;
+}
+declare const InvalidAnswerError_base: Schema.Class<InvalidAnswerError, Schema.TaggedStruct<"Form.InvalidAnswerError", {
+    readonly id: Schema.brand<Schema.String, "Form.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
+    };
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidAnswerError extends InvalidAnswerError_base {
+}
+declare const InvalidFormError_base: Schema.Class<InvalidFormError, Schema.TaggedStruct<"Form.InvalidFormError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidFormError extends InvalidFormError_base {
+}
+export type CreateInput = Omit<Form.Info, "id"> & {
+    readonly id?: ID;
+};
+export interface ReplyInput {
+    readonly id: ID;
+    readonly answer: Answer;
+}
+export interface ListInput {
+    readonly sessionID?: Form.Info["sessionID"];
+}
+export interface Interface {
+    readonly create: (input: CreateInput) => Effect.Effect<Info, AlreadyExistsError | InvalidFormError>;
+    readonly ask: (input: CreateInput) => Effect.Effect<TerminalState, AlreadyExistsError | InvalidFormError>;
+    readonly get: (id: ID) => Effect.Effect<Info, NotFoundError>;
+    readonly list: (input?: ListInput) => Effect.Effect<ReadonlyArray<Info>>;
+    readonly state: (id: ID) => Effect.Effect<State, NotFoundError>;
+    readonly reply: (input: ReplyInput) => Effect.Effect<void, AlreadySettledError | InvalidAnswerError | NotFoundError>;
+    readonly cancel: (id: ID) => Effect.Effect<void, AlreadySettledError | NotFoundError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Form", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, Bus.Service>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;
+export declare function validateAnswer(form: ReadonlyArray<Form.Field>, answer: Answer): string | undefined;
+export declare function validateFields(fields: ReadonlyArray<Form.Field>): string | undefined;

package/dist/types/formatter/builtins.d.ts

@@ -0,0 +1,18 @@
+import { Effect } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Npm } from "@opencode/util/npm";
+import { AppProcess } from "@opencode/util/process";
+export interface Info {
+    readonly name: string;
+    readonly environment?: Record<string, string>;
+    readonly extensions: readonly string[];
+    readonly enabled: Effect.Effect<string[] | false>;
+}
+export declare function make(input: {
+    readonly directory: string;
+    readonly worktree: string;
+    readonly fs: FSUtil.Interface;
+    readonly npm: Npm.Interface;
+    readonly processes: AppProcess.Interface;
+    readonly bin: string;
+}): Info[];

package/dist/types/formatter.d.ts

@@ -0,0 +1,15 @@
+export * as Formatter from "./formatter.js";
+import { Context, Effect } from "effect";
+import type { Info } from "./formatter/builtins.js";
+import { State } from "./state.js";
+export type Editor = {
+    set: (formatter: Info) => void;
+    remove: (name: string) => void;
+};
+export interface Interface extends State.Transformable<Editor> {
+    readonly file: (filepath: string) => Effect.Effect<boolean>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/v2/Formatter", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/generate.d.ts

@@ -0,0 +1,28 @@
+export * as Generate from "./generate.js";
+import { Context, Effect, Layer, Schema } from "effect";
+import { ModelResolver } from "./model-resolver.js";
+import { Model } from "./model.js";
+export interface TextInput {
+    readonly prompt: string;
+    readonly model?: Model.Ref;
+}
+declare const ModelSelectionError_base: Schema.Class<ModelSelectionError, Schema.TaggedStruct<"Generate.ModelSelectionError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ModelSelectionError extends ModelSelectionError_base {
+}
+declare const UnavailableError_base: Schema.Class<UnavailableError, Schema.TaggedStruct<"Generate.UnavailableError", {
+    readonly message: Schema.String;
+    readonly service: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+export declare class UnavailableError extends UnavailableError_base {
+}
+export type Error = ModelSelectionError | UnavailableError;
+export interface Interface {
+    readonly text: (input: TextInput) => Effect.Effect<string, Error>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Generate", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, import("@opencode/ai").LLMClientService | ModelResolver.Service>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;