@opencode-ai/schema 0.0.0-next-14659

package/dist/permission.d.ts

@@ -0,0 +1,346 @@
+export * as Permission from "./permission.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "PermissionV2.ID"> & {
+    create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Source: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"tool">;
+    readonly messageID: Schema.String;
+    readonly callID: Schema.String;
+}>]>;
+export type Source = typeof Source.Type;
+export declare const Request: 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 action: Schema.String;
+    readonly resources: Schema.$Array<Schema.String>;
+    readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+    readonly source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly callID: Schema.String;
+    }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tool">;
+        readonly messageID: Schema.String;
+        readonly callID: Schema.String;
+    }>]>>, never, never>;
+    readonly id: Schema.brand<Schema.String, "PermissionV2.ID"> & {
+        create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
+    };
+}>;
+export interface Request extends Schema.Schema.Type<typeof Request> {
+}
+export declare const Reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+export type Reply = typeof Reply.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 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.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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly action: Schema.String;
+            readonly resources: Schema.$Array<Schema.String>;
+            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>]>>, never, never>;
+            readonly id: Schema.brand<Schema.String, "PermissionV2.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.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 action: Schema.String;
+            readonly resources: Schema.$Array<Schema.String>;
+            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>]>>, never, never>;
+            readonly id: Schema.brand<Schema.String, "PermissionV2.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
+            };
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "permission.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<"permission.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, "PermissionV2.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+    }> & {
+        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, "PermissionV2.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "permission.v2.replied";
+    };
+    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<"permission.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 sessionID: Schema.brand<Schema.String, "SessionID"> & {
+                create: () => string & import("effect/Brand").Brand<"SessionID">;
+                descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+            };
+            readonly action: Schema.String;
+            readonly resources: Schema.$Array<Schema.String>;
+            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>]>>, never, never>;
+            readonly id: Schema.brand<Schema.String, "PermissionV2.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.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 action: Schema.String;
+            readonly resources: Schema.$Array<Schema.String>;
+            readonly save: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly source: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+                readonly type: Schema.Literal<"tool">;
+                readonly messageID: Schema.String;
+                readonly callID: Schema.String;
+            }>]>>, never, never>;
+            readonly id: Schema.brand<Schema.String, "PermissionV2.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
+            };
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "permission.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<"permission.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, "PermissionV2.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+    }> & {
+        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, "PermissionV2.ID"> & {
+                create: (id?: string) => string & import("effect/Brand").Brand<"PermissionV2.ID">;
+            };
+            readonly reply: Schema.Literals<readonly ["once", "always", "reject"]>;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "permission.v2.replied";
+    }];
+};
+export declare const Effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+export type Effect = typeof Effect.Type;
+export interface Rule extends Schema.Schema.Type<typeof Rule> {
+}
+export declare const Rule: Schema.Struct<{
+    readonly action: Schema.String;
+    readonly resource: Schema.String;
+    readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+}>;
+export declare const Ruleset: Schema.$Array<Schema.Struct<{
+    readonly action: Schema.String;
+    readonly resource: Schema.String;
+    readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+}>>;
+export type Ruleset = typeof Ruleset.Type;

package/dist/permission.js

@@ -0,0 +1,45 @@
+export * as Permission from "./permission.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("per")).pipe(Schema.brand("PermissionV2.ID"), statics((schema) => ({ create: (id) => schema.make(id ?? "per_" + ascending()) })));
+export const Source = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("tool"),
+        messageID: Schema.String,
+        callID: Schema.String,
+    }),
+]).annotate({ identifier: "PermissionV2.Source" });
+const RequestFields = {
+    sessionID: SessionID,
+    action: Schema.String,
+    resources: Schema.Array(Schema.String),
+    save: Schema.Array(Schema.String).pipe(optional),
+    metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
+    source: Source.pipe(optional),
+};
+export const Request = Schema.Struct({
+    id: ID,
+    ...RequestFields,
+}).annotate({ identifier: "PermissionV2.Request" });
+export const Reply = Schema.Literals(["once", "always", "reject"]).annotate({ identifier: "PermissionV2.Reply" });
+const Asked = define({ type: "permission.v2.asked", schema: Request.fields });
+const Replied = define({
+    type: "permission.v2.replied",
+    schema: {
+        sessionID: SessionID,
+        requestID: ID,
+        reply: Reply,
+    },
+});
+export const Event = { Asked, Replied, Definitions: inventory(Asked, Replied) };
+export const Effect = Schema.Literals(["allow", "deny", "ask"]).annotate({ identifier: "PermissionV2.Effect" });
+export const Rule = Schema.Struct({
+    action: Schema.String,
+    resource: Schema.String,
+    effect: Effect,
+}).annotate({ identifier: "PermissionV2.Rule" });
+export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionV2.Ruleset" });

package/dist/plugin.d.ts

@@ -0,0 +1,105 @@
+export * as Plugin from "./plugin.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "Plugin.ID">;
+export type ID = typeof ID.Type;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Plugin.ID">;
+}>;
+export declare const Event: {
+    Added: 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<"plugin.added">;
+        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, "Plugin.ID">;
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Plugin.ID">;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "plugin.added";
+    };
+    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<"plugin.added">;
+        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, "Plugin.ID">;
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "Plugin.ID">;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "plugin.added";
+    }];
+};

package/dist/plugin.js

@@ -0,0 +1,12 @@
+export * as Plugin from "./plugin.js";
+import { Schema } from "effect";
+import { define, inventory } from "./event.js";
+export const ID = Schema.String.pipe(Schema.brand("Plugin.ID"));
+export const Info = Schema.Struct({
+    id: ID,
+}).annotate({ identifier: "Plugin.Info" });
+const Added = define({
+    type: "plugin.added",
+    schema: { id: ID },
+});
+export const Event = { Added, Definitions: inventory(Added) };

package/dist/project-copy.d.ts

@@ -0,0 +1,29 @@
+export * as ProjectCopy from "./project-copy.js";
+import { Schema } from "effect";
+export declare const StrategyID: Schema.brand<Schema.Trim, "ProjectCopy.StrategyID">;
+export type StrategyID = typeof StrategyID.Type;
+export declare const CreateInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly strategy: Schema.brand<Schema.Trim, "ProjectCopy.StrategyID">;
+    readonly sourceDirectory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export interface CreateInput extends Schema.Schema.Type<typeof CreateInput> {
+}
+export declare const RemoveInput: Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly force: Schema.Boolean;
+}>;
+export interface RemoveInput extends Schema.Schema.Type<typeof RemoveInput> {
+}
+export declare const Copy: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+}>;
+export interface Copy extends Schema.Schema.Type<typeof Copy> {
+}

package/dist/project-copy.js

@@ -0,0 +1,21 @@
+export * as ProjectCopy from "./project-copy.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { ProjectID } from "./project-id.js";
+import { AbsolutePath } from "./schema.js";
+export const StrategyID = Schema.Trim.pipe(Schema.check(Schema.isNonEmpty()), Schema.brand("ProjectCopy.StrategyID"));
+export const CreateInput = Schema.Struct({
+    projectID: ProjectID,
+    strategy: StrategyID,
+    sourceDirectory: AbsolutePath,
+    directory: AbsolutePath,
+    name: optional(Schema.String),
+}).annotate({ identifier: "ProjectCopy.CreateInput" });
+export const RemoveInput = Schema.Struct({
+    projectID: ProjectID,
+    directory: AbsolutePath,
+    force: Schema.Boolean,
+}).annotate({ identifier: "ProjectCopy.RemoveInput" });
+export const Copy = Schema.Struct({
+    directory: AbsolutePath,
+}).annotate({ identifier: "ProjectCopy.Copy" });