@opencode-ai/schema 0.0.0-next-14659

package/dist/v1/question.d.ts

@@ -0,0 +1,504 @@
+export * as QuestionV1 from "./question.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "QuestionID"> & {
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+};
+export declare const Option: Schema.Struct<{
+    readonly label: Schema.String;
+    readonly description: Schema.String;
+}>;
+export declare const Info: Schema.Struct<{
+    readonly custom: Schema.optional<Schema.Boolean>;
+    readonly question: Schema.String;
+    readonly header: Schema.String;
+    readonly options: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.String;
+        readonly description: Schema.String;
+    }>>;
+    readonly multiple: Schema.optional<Schema.Boolean>;
+}>;
+export declare const Prompt: Schema.Struct<{
+    question: Schema.String;
+    header: Schema.String;
+    options: Schema.$Array<Schema.Struct<{
+        readonly label: Schema.String;
+        readonly description: Schema.String;
+    }>>;
+    multiple: Schema.optional<Schema.Boolean>;
+}>;
+export declare const Tool: Schema.Struct<{
+    readonly messageID: Schema.brand<Schema.String, "MessageID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"MessageID">;
+    };
+    readonly callID: Schema.String;
+}>;
+export declare const Request: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "QuestionID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+    };
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly questions: Schema.$Array<Schema.Struct<{
+        readonly custom: Schema.optional<Schema.Boolean>;
+        readonly question: Schema.String;
+        readonly header: Schema.String;
+        readonly options: Schema.$Array<Schema.Struct<{
+            readonly label: Schema.String;
+            readonly description: Schema.String;
+        }>>;
+        readonly multiple: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly tool: Schema.optional<Schema.Struct<{
+        readonly messageID: Schema.brand<Schema.String, "MessageID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"MessageID">;
+        };
+        readonly callID: Schema.String;
+    }>>;
+}>;
+export declare const Answer: Schema.$Array<Schema.String>;
+export declare const Reply: Schema.Struct<{
+    readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+}>;
+export declare const Replied: Schema.Struct<{
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly requestID: Schema.brand<Schema.String, "QuestionID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+    };
+    readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+}>;
+export declare const Rejected: Schema.Struct<{
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly requestID: Schema.brand<Schema.String, "QuestionID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+    };
+}>;
+export declare const Event: {
+    Asked: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        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<"question.asked">;
+        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>, never, never>;
+        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, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly questions: Schema.$Array<Schema.Struct<{
+                readonly custom: Schema.optional<Schema.Boolean>;
+                readonly question: Schema.String;
+                readonly header: Schema.String;
+                readonly options: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.String;
+                    readonly description: Schema.String;
+                }>>;
+                readonly multiple: Schema.optional<Schema.Boolean>;
+            }>>;
+            readonly tool: Schema.optional<Schema.Struct<{
+                readonly messageID: Schema.brand<Schema.String, "MessageID"> & {
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"MessageID">;
+                };
+                readonly callID: Schema.String;
+            }>>;
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly questions: Schema.$Array<Schema.Struct<{
+                readonly custom: Schema.optional<Schema.Boolean>;
+                readonly question: Schema.String;
+                readonly header: Schema.String;
+                readonly options: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.String;
+                    readonly description: Schema.String;
+                }>>;
+                readonly multiple: Schema.optional<Schema.Boolean>;
+            }>>;
+            readonly tool: Schema.optional<Schema.Struct<{
+                readonly messageID: Schema.brand<Schema.String, "MessageID"> & {
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"MessageID">;
+                };
+                readonly callID: Schema.String;
+            }>>;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.asked";
+    };
+    Replied: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        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<"question.replied">;
+        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>, never, never>;
+        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+            readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+            readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.replied";
+    };
+    Rejected: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        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<"question.rejected">;
+        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>, never, never>;
+        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.rejected";
+    };
+    Definitions: readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        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<"question.asked">;
+        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>, never, never>;
+        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, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly questions: Schema.$Array<Schema.Struct<{
+                readonly custom: Schema.optional<Schema.Boolean>;
+                readonly question: Schema.String;
+                readonly header: Schema.String;
+                readonly options: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.String;
+                    readonly description: Schema.String;
+                }>>;
+                readonly multiple: Schema.optional<Schema.Boolean>;
+            }>>;
+            readonly tool: Schema.optional<Schema.Struct<{
+                readonly messageID: Schema.brand<Schema.String, "MessageID"> & {
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"MessageID">;
+                };
+                readonly callID: Schema.String;
+            }>>;
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly questions: Schema.$Array<Schema.Struct<{
+                readonly custom: Schema.optional<Schema.Boolean>;
+                readonly question: Schema.String;
+                readonly header: Schema.String;
+                readonly options: Schema.$Array<Schema.Struct<{
+                    readonly label: Schema.String;
+                    readonly description: Schema.String;
+                }>>;
+                readonly multiple: Schema.optional<Schema.Boolean>;
+            }>>;
+            readonly tool: Schema.optional<Schema.Struct<{
+                readonly messageID: Schema.brand<Schema.String, "MessageID"> & {
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"MessageID">;
+                };
+                readonly callID: Schema.String;
+            }>>;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.asked";
+    }, Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        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<"question.replied">;
+        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>, never, never>;
+        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+            readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+            readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.replied";
+    }, Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        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<"question.rejected">;
+        readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly aggregateID: Schema.String;
+            readonly seq: Schema.Int;
+            readonly version: Schema.Int;
+        }>>, never, never>;
+        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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly requestID: Schema.brand<Schema.String, "QuestionID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionID">;
+            };
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.rejected";
+    }];
+};

package/dist/v1/question.js

@@ -0,0 +1,57 @@
+export * as QuestionV1 from "./question.js";
+import { Schema } from "effect";
+import { define, inventory } from "../event.js";
+import { ascending } from "../identifier.js";
+import { statics } from "../schema.js";
+import { SessionID } from "../session-id.js";
+import { SessionV1 } from "./session.js";
+export const ID = Schema.String.check(Schema.isStartsWith("que")).pipe(Schema.brand("QuestionID"), statics((schema) => ({ ascending: (id) => schema.make(id ?? "que_" + ascending()) })));
+export const Option = Schema.Struct({
+    label: Schema.String.annotate({ description: "Display text (1-5 words, concise)" }),
+    description: Schema.String.annotate({ description: "Explanation of choice" }),
+}).annotate({ identifier: "QuestionOption" });
+const base = {
+    question: Schema.String.annotate({ description: "Complete question" }),
+    header: Schema.String.annotate({ description: "Very short label (max 30 chars)" }),
+    options: Schema.Array(Option).annotate({ description: "Available choices" }),
+    multiple: Schema.optional(Schema.Boolean).annotate({ description: "Allow selecting multiple choices" }),
+};
+export const Info = Schema.Struct({
+    ...base,
+    custom: Schema.optional(Schema.Boolean).annotate({ description: "Allow typing a custom answer (default: true)" }),
+}).annotate({ identifier: "QuestionInfo" });
+export const Prompt = Schema.Struct(base).annotate({ identifier: "QuestionPrompt" });
+export const Tool = Schema.Struct({ messageID: SessionV1.MessageID, callID: Schema.String }).annotate({
+    identifier: "QuestionTool",
+});
+export const Request = Schema.Struct({
+    id: ID,
+    sessionID: SessionID,
+    questions: Schema.Array(Info).annotate({ description: "Questions to ask" }),
+    tool: Schema.optional(Tool),
+}).annotate({ identifier: "QuestionRequest" });
+export const Answer = Schema.Array(Schema.String).annotate({ identifier: "QuestionAnswer" });
+export const Reply = Schema.Struct({
+    answers: Schema.Array(Answer).annotate({
+        description: "User answers in order of questions (each answer is an array of selected labels)",
+    }),
+}).annotate({ identifier: "QuestionReply" });
+export const Replied = Schema.Struct({
+    sessionID: SessionID,
+    requestID: ID,
+    answers: Schema.Array(Answer),
+}).annotate({
+    identifier: "QuestionReplied",
+});
+export const Rejected = Schema.Struct({ sessionID: SessionID, requestID: ID }).annotate({
+    identifier: "QuestionRejected",
+});
+const Asked = define({ type: "question.asked", schema: Request.fields });
+const RepliedEvent = define({ type: "question.replied", schema: Replied.fields });
+const RejectedEvent = define({ type: "question.rejected", schema: Rejected.fields });
+export const Event = {
+    Asked,
+    Replied: RepliedEvent,
+    Rejected: RejectedEvent,
+    Definitions: inventory(Asked, RepliedEvent, RejectedEvent),
+};