@opencode-ai/schema 0.0.0-dev-17471

package/dist/v1/legacy-event.d.ts

@@ -0,0 +1,108 @@
+export * as LegacyEventV1 from "./legacy-event.js";
+import { Schema } from "effect";
+export declare const CommandExecuted: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"command.executed">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly arguments: Schema.String;
+        readonly messageID: Schema.brand<Schema.String, "SessionV1.MessageID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"SessionV1.MessageID">;
+        };
+    }>;
+}> & {
+    type: "command.executed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly arguments: Schema.String;
+        readonly messageID: Schema.brand<Schema.String, "SessionV1.MessageID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"SessionV1.MessageID">;
+        };
+    }>;
+};
+export declare const Definitions: readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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<"command.executed">;
+    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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly arguments: Schema.String;
+        readonly messageID: Schema.brand<Schema.String, "SessionV1.MessageID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"SessionV1.MessageID">;
+        };
+    }>;
+}> & {
+    type: "command.executed";
+    durability: "ephemeral";
+    durable: undefined;
+    data: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+        readonly arguments: Schema.String;
+        readonly messageID: Schema.brand<Schema.String, "SessionV1.MessageID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"SessionV1.MessageID">;
+        };
+    }>;
+}];

package/dist/v1/legacy-event.js

@@ -0,0 +1,15 @@
+export * as LegacyEventV1 from "./legacy-event.js";
+import { Schema } from "effect";
+import { ephemeral, inventory } from "../event.js";
+import { SessionID } from "../session-id.js";
+import { SessionV1 } from "./session.js";
+export const CommandExecuted = ephemeral({
+    type: "command.executed",
+    schema: {
+        name: Schema.String,
+        sessionID: SessionID,
+        arguments: Schema.String,
+        messageID: SessionV1.MessageID,
+    },
+});
+export const Definitions = inventory(CommandExecuted);

package/dist/v1/permission.d.ts

@@ -0,0 +1,316 @@
+export * as PermissionV1 from "./permission.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "PermissionV1.ID"> & {
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Action: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+export type Action = typeof Action.Type;
+export declare const Rule: Schema.Struct<{
+    readonly permission: Schema.String;
+    readonly pattern: Schema.String;
+    readonly action: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+}>;
+export type Rule = typeof Rule.Type;
+export declare const Ruleset: Schema.$Array<Schema.Struct<{
+    readonly permission: Schema.String;
+    readonly pattern: Schema.String;
+    readonly action: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+}>>;
+export type Ruleset = typeof Ruleset.Type;
+export declare const Request: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "PermissionV1.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.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 permission: Schema.String;
+    readonly patterns: Schema.$Array<Schema.String>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly always: Schema.$Array<Schema.String>;
+    readonly tool: Schema.optional<Schema.Struct<{
+        readonly messageID: Schema.String;
+        readonly callID: Schema.String;
+    }>>;
+}>;
+export type Request = typeof Request.Type;
+export declare const Reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+export type Reply = typeof Reply.Type;
+export declare const ReplyBody: Schema.Struct<{
+    readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+    readonly message: Schema.optional<Schema.String>;
+}>;
+export type ReplyBody = typeof ReplyBody.Type;
+export declare const Approval: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly patterns: Schema.$Array<Schema.String>;
+}>;
+export type Approval = typeof Approval.Type;
+export declare const AskInput: Schema.Struct<{
+    readonly id: Schema.optional<Schema.brand<Schema.String, "PermissionV1.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.ID">;
+    }>;
+    readonly ruleset: Schema.$Array<Schema.Struct<{
+        readonly permission: Schema.String;
+        readonly pattern: Schema.String;
+        readonly action: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>;
+    readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+        create: () => string & import("effect/Brand").Brand<"SessionID">;
+        descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+    };
+    readonly permission: Schema.String;
+    readonly patterns: Schema.$Array<Schema.String>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly always: Schema.$Array<Schema.String>;
+    readonly tool: Schema.optional<Schema.Struct<{
+        readonly messageID: Schema.String;
+        readonly callID: Schema.String;
+    }>>;
+}>;
+export type AskInput = typeof AskInput.Type;
+export declare const ReplyInput: Schema.Struct<{
+    readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+    readonly message: Schema.optional<Schema.String>;
+    readonly requestID: Schema.brand<Schema.String, "PermissionV1.ID"> & {
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.ID">;
+    };
+}>;
+export type ReplyInput = typeof ReplyInput.Type;
+export declare const Event: {
+    Asked: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        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<"permission.asked">;
+        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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "PermissionV1.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.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 permission: Schema.String;
+            readonly patterns: Schema.$Array<Schema.String>;
+            readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+            readonly always: Schema.$Array<Schema.String>;
+            readonly tool: Schema.optional<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>;
+        }>;
+    }> & {
+        type: "permission.asked";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "PermissionV1.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.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 permission: Schema.String;
+            readonly patterns: Schema.$Array<Schema.String>;
+            readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+            readonly always: Schema.$Array<Schema.String>;
+            readonly tool: Schema.optional<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>;
+        }>;
+    };
+    Replied: Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        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<"permission.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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.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, "PermissionV1.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+    }> & {
+        type: "permission.replied";
+        durability: "ephemeral";
+        durable: undefined;
+        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, "PermissionV1.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+    };
+    Definitions: readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        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<"permission.asked">;
+        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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>, never, never>;
+        readonly data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "PermissionV1.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.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 permission: Schema.String;
+            readonly patterns: Schema.$Array<Schema.String>;
+            readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+            readonly always: Schema.$Array<Schema.String>;
+            readonly tool: Schema.optional<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>;
+        }>;
+    }> & {
+        type: "permission.asked";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "PermissionV1.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.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 permission: Schema.String;
+            readonly patterns: Schema.$Array<Schema.String>;
+            readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+            readonly always: Schema.$Array<Schema.String>;
+            readonly tool: Schema.optional<Schema.Struct<{
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>>;
+        }>;
+    }, Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: Schema.Finite;
+        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<"permission.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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.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, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.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, "PermissionV1.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+    }> & {
+        type: "permission.replied";
+        durability: "ephemeral";
+        durable: undefined;
+        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, "PermissionV1.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"PermissionV1.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+    }];
+};

package/dist/v1/permission.js

@@ -0,0 +1,41 @@
+export * as PermissionV1 from "./permission.js";
+import { Schema } from "effect";
+import { ephemeral, inventory } from "../event.js";
+import { ascending } from "../identifier.js";
+import { Project } from "../project.js";
+import { statics } from "../schema.js";
+import { SessionID } from "../session-id.js";
+export const ID = Schema.String.check(Schema.isStartsWith("per")).pipe(Schema.brand("PermissionV1.ID"), statics((schema) => ({ ascending: (id) => schema.make(id ?? "per_" + ascending()) })));
+export const Action = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "PermissionV1.Action" });
+export const Rule = Schema.Struct({ permission: Schema.String, pattern: Schema.String, action: Action }).annotate({
+    identifier: "PermissionV1.Rule",
+});
+export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionV1.Ruleset" });
+export const Request = Schema.Struct({
+    id: ID,
+    sessionID: SessionID,
+    permission: Schema.String,
+    patterns: Schema.Array(Schema.String),
+    metadata: Schema.Record(Schema.String, Schema.Unknown),
+    always: Schema.Array(Schema.String),
+    tool: Schema.optional(Schema.Struct({ messageID: Schema.String, callID: Schema.String })),
+}).annotate({ identifier: "PermissionV1.Request" });
+export const Reply = Schema.Literals(["once", "always", "reject"]);
+export const ReplyBody = Schema.Struct({ reply: Reply, message: Schema.optional(Schema.String) }).annotate({
+    identifier: "PermissionV1.ReplyBody",
+});
+export const Approval = Schema.Struct({ projectID: Project.ID, patterns: Schema.Array(Schema.String) }).annotate({
+    identifier: "PermissionV1.Approval",
+});
+export const AskInput = Schema.Struct({ ...Request.fields, id: Schema.optional(ID), ruleset: Ruleset }).annotate({
+    identifier: "PermissionV1.AskInput",
+});
+export const ReplyInput = Schema.Struct({ requestID: ID, ...ReplyBody.fields }).annotate({
+    identifier: "PermissionV1.ReplyInput",
+});
+const Asked = ephemeral({ type: "permission.asked", schema: Request.fields });
+const Replied = ephemeral({
+    type: "permission.replied",
+    schema: { sessionID: SessionID, requestID: ID, reply: Reply },
+});
+export const Event = { Asked, Replied, Definitions: inventory(Asked, Replied) };