@opencode-ai/schema 0.0.0-next-14855 → 0.0.0-reserved.0

package/dist/form.d.ts

@@ -1,1279 +0,0 @@
-export * as Form from "./form.js";
-import { Schema } from "effect";
-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 Metadata: Schema.$Record<Schema.String, Schema.Unknown>;
-export type Metadata = typeof Metadata.Type;
-export declare const Option: 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>;
-}>;
-export interface Option extends Schema.Schema.Type<typeof Option> {
-}
-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 interface When extends Schema.Schema.Type<typeof When> {
-}
-export declare const StringField: 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>;
-}>;
-export interface StringField extends Schema.Schema.Type<typeof StringField> {
-}
-export declare const NumberField: 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>;
-}>;
-export interface NumberField extends Schema.Schema.Type<typeof NumberField> {
-}
-export declare const IntegerField: 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>;
-}>;
-export interface IntegerField extends Schema.Schema.Type<typeof IntegerField> {
-}
-export declare const BooleanField: 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>;
-}>;
-export interface BooleanField extends Schema.Schema.Type<typeof BooleanField> {
-}
-export declare const MultiselectField: 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>;
-}>;
-export interface MultiselectField extends Schema.Schema.Type<typeof MultiselectField> {
-}
-export declare const Field: Schema.toTaggedUnion<"type", 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>;
-}>]>;
-export type Field = StringField | NumberField | IntegerField | BooleanField | MultiselectField;
-export declare const FormInfo: Schema.Struct<{
-    readonly mode: Schema.Literal<"form">;
-    readonly fields: Schema.$Array<Schema.toTaggedUnion<"type", 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>;
-    }>]>>;
-    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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    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 interface FormInfo extends Schema.Schema.Type<typeof FormInfo> {
-}
-export declare const UrlInfo: Schema.Struct<{
-    readonly mode: Schema.Literal<"url">;
-    readonly url: Schema.String;
-    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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    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 interface UrlInfo extends Schema.Schema.Type<typeof UrlInfo> {
-}
-export declare const Info: Schema.toTaggedUnion<"mode", readonly [Schema.Struct<{
-    readonly mode: Schema.Literal<"form">;
-    readonly fields: Schema.$Array<Schema.toTaggedUnion<"type", 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>;
-    }>]>>;
-    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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-}>, Schema.Struct<{
-    readonly mode: Schema.Literal<"url">;
-    readonly url: Schema.String;
-    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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    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 = FormInfo | UrlInfo;
-export declare const Value: Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>;
-export type Value = typeof Value.Type;
-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 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 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 interface Reply extends Schema.Schema.Type<typeof Reply> {
-}
-export declare const Event: {
-    Created: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly type: Schema.Literal<"form.created">;
-        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>, never, never>;
-        readonly data: Schema.Struct<{
-            readonly form: Schema.toTaggedUnion<"mode", readonly [Schema.Struct<{
-                readonly mode: Schema.Literal<"form">;
-                readonly fields: Schema.$Array<Schema.toTaggedUnion<"type", 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>;
-                }>]>>;
-                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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-            }>, Schema.Struct<{
-                readonly mode: Schema.Literal<"url">;
-                readonly url: Schema.String;
-                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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-            }>]>;
-        }>;
-    }> & {
-        type: "form.created";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly form: Schema.toTaggedUnion<"mode", readonly [Schema.Struct<{
-                readonly mode: Schema.Literal<"form">;
-                readonly fields: Schema.$Array<Schema.toTaggedUnion<"type", 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>;
-                }>]>>;
-                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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-            }>, Schema.Struct<{
-                readonly mode: Schema.Literal<"url">;
-                readonly url: Schema.String;
-                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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-            }>]>;
-        }>;
-    };
-    Replied: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly type: Schema.Literal<"form.replied">;
-        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>, never, never>;
-        readonly data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Form.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
-            };
-            readonly sessionID: Schema.String;
-            readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
-        }>;
-    }> & {
-        type: "form.replied";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Form.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
-            };
-            readonly sessionID: Schema.String;
-            readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
-        }>;
-    };
-    Cancelled: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly type: Schema.Literal<"form.cancelled">;
-        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>, never, never>;
-        readonly data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Form.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
-            };
-            readonly sessionID: Schema.String;
-        }>;
-    }> & {
-        type: "form.cancelled";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Form.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
-            };
-            readonly sessionID: Schema.String;
-        }>;
-    };
-    Definitions: readonly [Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly type: Schema.Literal<"form.created">;
-        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>, never, never>;
-        readonly data: Schema.Struct<{
-            readonly form: Schema.toTaggedUnion<"mode", readonly [Schema.Struct<{
-                readonly mode: Schema.Literal<"form">;
-                readonly fields: Schema.$Array<Schema.toTaggedUnion<"type", 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>;
-                }>]>>;
-                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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-            }>, Schema.Struct<{
-                readonly mode: Schema.Literal<"url">;
-                readonly url: Schema.String;
-                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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-            }>]>;
-        }>;
-    }> & {
-        type: "form.created";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly form: Schema.toTaggedUnion<"mode", readonly [Schema.Struct<{
-                readonly mode: Schema.Literal<"form">;
-                readonly fields: Schema.$Array<Schema.toTaggedUnion<"type", 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>;
-                }>]>>;
-                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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-            }>, Schema.Struct<{
-                readonly mode: Schema.Literal<"url">;
-                readonly url: Schema.String;
-                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.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-                readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-            }>]>;
-        }>;
-    }, Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly type: Schema.Literal<"form.replied">;
-        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>, never, never>;
-        readonly data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Form.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
-            };
-            readonly sessionID: Schema.String;
-            readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
-        }>;
-    }> & {
-        type: "form.replied";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Form.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
-            };
-            readonly sessionID: Schema.String;
-            readonly answer: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean, Schema.$Array<Schema.String>]>>;
-        }>;
-    }, Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly type: Schema.Literal<"form.cancelled">;
-        readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-            readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>>, Schema.optionalKey<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-                create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
-            }>, never, never>;
-        }>>, never, never>;
-        readonly data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Form.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
-            };
-            readonly sessionID: Schema.String;
-        }>;
-    }> & {
-        type: "form.cancelled";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "Form.ID"> & {
-                create: (id?: string) => string & import("effect/Brand").Brand<"Form.ID">;
-            };
-            readonly sessionID: Schema.String;
-        }>;
-    }];
-};