@opencode-ai/schema 0.0.0-next-14659

package/dist/question.d.ts

@@ -0,0 +1,516 @@
+export * as Question from "./question.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "QuestionV2.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Option: Schema.Struct<{
+    readonly label: Schema.String;
+    readonly description: Schema.String;
+}>;
+export interface Option extends Schema.Schema.Type<typeof Option> {
+}
+export declare const Info: Schema.Struct<{
+    readonly custom: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;
+export interface Prompt extends Schema.Schema.Type<typeof Prompt> {
+}
+export declare const Tool: Schema.Struct<{
+    readonly messageID: Schema.String;
+    readonly callID: Schema.String;
+}>;
+export interface Tool extends Schema.Schema.Type<typeof Tool> {
+}
+export declare const Request: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "QuestionV2.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+    };
+    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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>;
+    readonly tool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly messageID: Schema.String;
+        readonly callID: Schema.String;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly messageID: Schema.String;
+        readonly callID: Schema.String;
+    }>>, never, never>;
+}>;
+export interface Request extends Schema.Schema.Type<typeof Request> {
+}
+export declare const Answer: Schema.$Array<Schema.String>;
+export type Answer = typeof Answer.Type;
+export declare const Reply: Schema.Struct<{
+    readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+}>;
+export interface Reply extends Schema.Schema.Type<typeof Reply> {
+}
+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.v2.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, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+            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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+                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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            }>>;
+            readonly tool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>, never, never>;
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+            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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+                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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            }>>;
+            readonly tool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>, never, never>;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.v2.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.v2.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, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+            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, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+            readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.v2.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.v2.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, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+        }>;
+    }> & {
+        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, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.v2.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.v2.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, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+            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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+                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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            }>>;
+            readonly tool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>, never, never>;
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+            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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+                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.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+            }>>;
+            readonly tool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>, never, never>;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.v2.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.v2.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, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+            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, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+            readonly answers: Schema.$Array<Schema.$Array<Schema.String>>;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.v2.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.v2.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, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+        }>;
+    }> & {
+        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, "QuestionV2.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"QuestionV2.ID">;
+            };
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "question.v2.rejected";
+    }];
+};

package/dist/question.js

@@ -0,0 +1,64 @@
+export * as Question from "./question.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { define, inventory } from "./event.js";
+import { ascending } from "./identifier.js";
+import { SessionID } from "./session-id.js";
+import { statics } from "./schema.js";
+export const ID = Schema.String.check(Schema.isStartsWith("que")).pipe(Schema.brand("QuestionV2.ID"), statics((schema) => {
+    const create = () => schema.make("que_" + ascending());
+    return {
+        create,
+        ascending: (id) => (id === undefined ? create() : schema.make(id)),
+    };
+}));
+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: "QuestionV2.Option" });
+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.Boolean.pipe(optional).annotate({ description: "Allow selecting multiple choices" }),
+};
+export const Info = Schema.Struct({
+    ...base,
+    custom: Schema.Boolean.pipe(optional).annotate({
+        description: "Allow typing a custom answer (default: true)",
+    }),
+}).annotate({ identifier: "QuestionV2.Info" });
+export const Prompt = Schema.Struct(base).annotate({ identifier: "QuestionV2.Prompt" });
+export const Tool = Schema.Struct({
+    messageID: Schema.String,
+    callID: Schema.String,
+}).annotate({ identifier: "QuestionV2.Tool" });
+export const Request = Schema.Struct({
+    id: ID,
+    sessionID: SessionID,
+    questions: Schema.Array(Info).annotate({ description: "Questions to ask" }),
+    tool: Tool.pipe(optional),
+}).annotate({ identifier: "QuestionV2.Request" });
+export const Answer = Schema.Array(Schema.String).annotate({ identifier: "QuestionV2.Answer" });
+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: "QuestionV2.Reply" });
+const Asked = define({ type: "question.v2.asked", schema: Request.fields });
+const Replied = define({
+    type: "question.v2.replied",
+    schema: {
+        sessionID: SessionID,
+        requestID: ID,
+        answers: Schema.Array(Answer),
+    },
+});
+const Rejected = define({
+    type: "question.v2.rejected",
+    schema: {
+        sessionID: SessionID,
+        requestID: ID,
+    },
+});
+export const Event = { Asked, Replied, Rejected, Definitions: inventory(Asked, Replied, Rejected) };