@opencode-ai/schema 0.0.0-dev-17471

package/dist/mcp.js

@@ -0,0 +1,111 @@
+export * as Mcp from "./mcp.js";
+import { Schema } from "effect";
+import { optional, PositiveInt } from "./schema.js";
+import { IntegrationID } from "./integration-id.js";
+export class TimeoutConfig extends Schema.Class("Mcp.TimeoutConfig")({
+    startup: PositiveInt.pipe(optional).annotate({
+        description: "Maximum time in milliseconds to establish and initialize the MCP server.",
+    }),
+    catalog: PositiveInt.pipe(optional).annotate({
+        description: "Maximum time in milliseconds to wait for MCP discovery requests such as tools/list and prompts/list.",
+    }),
+    execution: PositiveInt.pipe(optional).annotate({
+        description: "Maximum time in milliseconds to wait for MCP tool and prompt execution.",
+    }),
+}) {
+}
+export class LocalConfig extends Schema.Class("Mcp.LocalConfig")({
+    type: Schema.Literal("local"),
+    command: Schema.String.pipe(Schema.Array),
+    cwd: Schema.String.pipe(optional).annotate({
+        description: "Working directory for the MCP server process. Relative paths resolve from the workspace directory.",
+    }),
+    environment: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    disabled: Schema.Boolean.pipe(optional),
+    codemode: Schema.Boolean.pipe(optional).annotate({
+        description: "Expose this server's tools through Code Mode. Defaults to true.",
+    }),
+    timeout: TimeoutConfig.pipe(optional),
+}) {
+}
+export class OAuthConfig extends Schema.Class("Mcp.OAuthConfig")({
+    client_id: Schema.String.pipe(optional),
+    client_secret: Schema.String.pipe(optional),
+    scope: Schema.String.pipe(optional),
+    callback_port: Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 65535 })).pipe(optional),
+    redirect_uri: Schema.String.pipe(optional),
+}) {
+}
+export class RemoteConfig extends Schema.Class("Mcp.RemoteConfig")({
+    type: Schema.Literal("remote"),
+    url: Schema.String,
+    headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    oauth: Schema.Union([OAuthConfig, Schema.Literal(false)]).pipe(optional),
+    disabled: Schema.Boolean.pipe(optional),
+    codemode: Schema.Boolean.pipe(optional).annotate({
+        description: "Expose this server's tools through Code Mode. Defaults to true.",
+    }),
+    timeout: TimeoutConfig.pipe(optional),
+}) {
+}
+export const ServerConfig = Schema.Union([LocalConfig, RemoteConfig]).pipe(Schema.toTaggedUnion("type"));
+const Connected = Schema.Struct({ status: Schema.Literal("connected") }).annotate({
+    identifier: "Mcp.Status.Connected",
+});
+const Pending = Schema.Struct({ status: Schema.Literal("pending") }).annotate({
+    identifier: "Mcp.Status.Pending",
+});
+const Disabled = Schema.Struct({ status: Schema.Literal("disabled") }).annotate({
+    identifier: "Mcp.Status.Disabled",
+});
+const Failed = Schema.Struct({ status: Schema.Literal("failed"), error: Schema.String }).annotate({
+    identifier: "Mcp.Status.Failed",
+});
+const NeedsAuth = Schema.Struct({ status: Schema.Literal("needs_auth") }).annotate({
+    identifier: "Mcp.Status.NeedsAuth",
+});
+export const Status = Schema.Union([Connected, Pending, Disabled, Failed, NeedsAuth]).pipe(Schema.toTaggedUnion("status"));
+export const Server = Schema.Struct({
+    name: Schema.String,
+    status: Status,
+    // Set for remote servers registered as OAuth integrations; lets clients act on the right integration
+    // without matching by name, which could collide with provider or plugin integrations.
+    integrationID: optional(IntegrationID),
+}).annotate({ identifier: "Mcp.Server" });
+export const Resource = Schema.Struct({
+    server: Schema.String,
+    name: Schema.String,
+    uri: Schema.String,
+    description: optional(Schema.String),
+    mimeType: optional(Schema.String),
+}).annotate({ identifier: "Mcp.Resource" });
+export const ResourceTemplate = Schema.Struct({
+    server: Schema.String,
+    name: Schema.String,
+    uriTemplate: Schema.String,
+    description: optional(Schema.String),
+    mimeType: optional(Schema.String),
+}).annotate({ identifier: "Mcp.ResourceTemplate" });
+export const ResourceCatalog = Schema.Struct({
+    resources: Schema.Array(Resource),
+    templates: Schema.Array(ResourceTemplate),
+}).annotate({ identifier: "Mcp.ResourceCatalog" });
+export const ResourceContentPart = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("text"),
+        uri: Schema.String,
+        text: Schema.String,
+        mimeType: optional(Schema.String),
+    }),
+    Schema.Struct({
+        type: Schema.Literal("blob"),
+        uri: Schema.String,
+        blob: Schema.String,
+        mimeType: optional(Schema.String),
+    }),
+]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "Mcp.ResourceContentPart" }));
+export const ResourceContent = Schema.Struct({
+    server: Schema.String,
+    uri: Schema.String,
+    contents: Schema.Array(ResourceContentPart),
+}).annotate({ identifier: "Mcp.ResourceContent" });

package/dist/model.d.ts

@@ -0,0 +1,186 @@
+export * as Model from "./model.js";
+import { Schema } from "effect";
+import { Provider } from "./provider.js";
+export declare const ID: Schema.brand<Schema.String, "Model.ID">;
+export type ID = typeof ID.Type;
+export declare const VariantID: Schema.brand<Schema.String, "Model.VariantID">;
+export type VariantID = typeof VariantID.Type;
+export declare const Ref: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Model.ID">;
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+}> & {
+    parse: (input: string) => {
+        readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+        readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+        readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+    };
+};
+export interface Ref extends Schema.Schema.Type<typeof Ref> {
+}
+export declare const Family: Schema.brand<Schema.String, "Model.Family">;
+export type Family = typeof Family.Type;
+export type ReasoningField = "reasoning" | "reasoning_content" | "reasoning_text" | (string & {});
+export declare const ReasoningField: Schema.Codec<ReasoningField>;
+export declare const MaxTokensField: Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>;
+export type MaxTokensField = typeof MaxTokensField.Type;
+export interface Compatibility extends Schema.Schema.Type<typeof Compatibility> {
+}
+export declare const Compatibility: Schema.Struct<{
+    readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
+    readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+    readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;
+export interface Capabilities extends Schema.Schema.Type<typeof Capabilities> {
+}
+export declare const Capabilities: Schema.Struct<{
+    readonly tools: Schema.Boolean;
+    readonly input: Schema.$Array<Schema.String>;
+    readonly output: Schema.$Array<Schema.String>;
+}>;
+export interface Cost extends Schema.Schema.Type<typeof Cost> {
+}
+export declare const Cost: Schema.Struct<{
+    readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly type: Schema.tag<"context">;
+        readonly size: Schema.Int;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly type: Schema.tag<"context">;
+        readonly size: Schema.Int;
+    }>>, never, never>;
+    readonly input: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    };
+    readonly output: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+    };
+    readonly cache: Schema.Struct<{
+        readonly read: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly write: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+    }>;
+}>;
+export interface Variant extends Schema.Schema.Type<typeof Variant> {
+}
+export declare const Variant: Schema.Struct<{
+    readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly id: Schema.brand<Schema.String, "Model.VariantID">;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly capabilities: Schema.Struct<{
+        readonly tools: Schema.Boolean;
+        readonly input: Schema.$Array<Schema.String>;
+        readonly output: Schema.$Array<Schema.String>;
+    }>;
+    readonly variants: Schema.$Array<Schema.Struct<{
+        readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+        readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+        readonly id: Schema.brand<Schema.String, "Model.VariantID">;
+    }>>;
+    readonly time: Schema.Struct<{
+        readonly released: Schema.Finite;
+    }>;
+    readonly cost: Schema.$Array<Schema.Struct<{
+        readonly tier: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.tag<"context">;
+            readonly size: Schema.Int;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.tag<"context">;
+            readonly size: Schema.Int;
+        }>>, never, never>;
+        readonly input: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly output: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+            zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+        };
+        readonly cache: Schema.Struct<{
+            readonly read: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+            readonly write: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+                zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+            };
+        }>;
+    }>>;
+    readonly status: Schema.Literals<readonly ["alpha", "beta", "deprecated", "active"]>;
+    readonly enabled: Schema.Boolean;
+    readonly limit: Schema.Struct<{
+        readonly context: Schema.Int;
+        readonly input: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+        readonly output: Schema.Int;
+    }>;
+    readonly settings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
+    readonly id: Schema.brand<Schema.String, "Model.ID">;
+    readonly modelID: Schema.brand<Schema.String, "Model.ID">;
+    readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+        opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+        anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+        openai: string & import("effect/Brand").Brand<"Provider.ID">;
+        google: string & import("effect/Brand").Brand<"Provider.ID">;
+        googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+        githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+        amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+        azure: string & import("effect/Brand").Brand<"Provider.ID">;
+        openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+        mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+        gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+    };
+    readonly family: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.Family">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.Family">>, never, never>;
+    readonly name: Schema.String;
+    readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<ReasoningField, ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<ReasoningField, ReasoningField, never, never>>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>, never, never>;
+    readonly package: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}> & {
+    default: (providerID: Provider.ID, id: ID) => {
+        id: string & import("effect/Brand").Brand<"Model.ID">;
+        modelID: string & import("effect/Brand").Brand<"Model.ID">;
+        providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+        name: string & import("effect/Brand").Brand<"Model.ID">;
+        capabilities: {
+            tools: true;
+            input: string[];
+            output: string[];
+        };
+        variants: never[];
+        time: {
+            released: number;
+        };
+        cost: never[];
+        status: "active";
+        enabled: true;
+        limit: {
+            context: number;
+            output: number;
+        };
+    };
+};

package/dist/model.js

@@ -0,0 +1,104 @@
+export * as Model from "./model.js";
+import { Schema } from "effect";
+import { optional, statics } from "./schema.js";
+import { Provider } from "./provider.js";
+import { Money } from "./money.js";
+export const ID = Schema.String.pipe(Schema.brand("Model.ID"));
+export const VariantID = Schema.String.pipe(Schema.brand("Model.VariantID"));
+export const Ref = Schema.Struct({
+    id: ID,
+    providerID: Provider.ID,
+    variant: VariantID.pipe(optional),
+})
+    .annotate({ identifier: "Model.Ref" })
+    .pipe(statics((schema) => ({
+    parse: (input) => {
+        const providerEnd = input.indexOf("/");
+        if (providerEnd <= 0)
+            throw new Error(`Invalid model reference: ${input}`);
+        const providerID = input.slice(0, providerEnd);
+        const variantStart = input.indexOf("#", providerEnd + 1);
+        const id = input.slice(providerEnd + 1, variantStart === -1 ? undefined : variantStart);
+        const variant = variantStart === -1 ? undefined : input.slice(variantStart + 1);
+        if (!id || providerID.includes("#") || (variant !== undefined && (!variant || variant.includes("#"))))
+            throw new Error(`Invalid model reference: ${input}`);
+        return schema.make({
+            providerID: Provider.ID.make(providerID),
+            id: ID.make(id),
+            ...(variant ? { variant: VariantID.make(variant) } : {}),
+        });
+    },
+})));
+export const Family = Schema.String.pipe(Schema.brand("Model.Family"));
+export const ReasoningField = Schema.Union([
+    Schema.Literals(["reasoning", "reasoning_content", "reasoning_text"]),
+    Schema.String,
+]).annotate({ identifier: "Model.ReasoningField" });
+export const MaxTokensField = Schema.Literals(["max_completion_tokens", "max_tokens"]).annotate({
+    identifier: "Model.MaxTokensField",
+});
+export const Compatibility = Schema.Struct({
+    reasoningField: ReasoningField.pipe(optional),
+    maxTokensField: MaxTokensField.pipe(optional),
+    requireFinishReason: Schema.Boolean.pipe(optional),
+}).annotate({ identifier: "Model.Compatibility" });
+export const Capabilities = Schema.Struct({
+    tools: Schema.Boolean,
+    input: Schema.Array(Schema.String),
+    output: Schema.Array(Schema.String),
+}).annotate({ identifier: "Model.Capabilities" });
+export const Cost = Schema.Struct({
+    tier: Schema.Struct({
+        type: Schema.tag("context"),
+        size: Schema.Int,
+    }).pipe(optional),
+    input: Money.USDPerMillionTokens,
+    output: Money.USDPerMillionTokens,
+    cache: Schema.Struct({
+        read: Money.USDPerMillionTokens,
+        write: Money.USDPerMillionTokens,
+    }),
+}).annotate({ identifier: "Model.Cost" });
+export const Variant = Schema.Struct({
+    id: VariantID,
+    ...Provider.Overlays,
+}).annotate({ identifier: "Model.Variant" });
+export const Info = Schema.Struct({
+    id: ID,
+    modelID: ID,
+    providerID: Provider.ID,
+    family: Family.pipe(optional),
+    name: Schema.String,
+    compatibility: Compatibility.pipe(optional),
+    package: Provider.Package.pipe(optional),
+    ...Provider.Overlays,
+    capabilities: Capabilities,
+    variants: Schema.Array(Variant),
+    time: Schema.Struct({
+        released: Schema.Finite,
+    }),
+    cost: Schema.Array(Cost),
+    status: Schema.Literals(["alpha", "beta", "deprecated", "active"]),
+    enabled: Schema.Boolean,
+    limit: Schema.Struct({
+        context: Schema.Int,
+        input: Schema.Int.pipe(optional),
+        output: Schema.Int,
+    }),
+})
+    .annotate({ identifier: "Model.Info" })
+    .pipe(statics(() => ({
+    default: (providerID, id) => ({
+        id,
+        modelID: id,
+        providerID,
+        name: id,
+        capabilities: { tools: true, input: ["text", "image"], output: ["text"] },
+        variants: [],
+        time: { released: 0 },
+        cost: [],
+        status: "active",
+        enabled: true,
+        limit: { context: 0, output: 0 },
+    }),
+})));

package/dist/models-dev.d.ts

@@ -0,0 +1,69 @@
+export * as ModelsDev from "./models-dev.js";
+export declare const Event: {
+    Refreshed: import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: import("effect/Schema").Finite;
+        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+        readonly type: import("effect/Schema").Literal<"models-dev.refreshed">;
+        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{}>;
+    }> & {
+        type: "models-dev.refreshed";
+        durability: "ephemeral";
+        durable: undefined;
+        data: import("effect/Schema").Struct<{}>;
+    };
+    Definitions: readonly [import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: import("effect/Schema").Finite;
+        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+        readonly type: import("effect/Schema").Literal<"models-dev.refreshed">;
+        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{}>;
+    }> & {
+        type: "models-dev.refreshed";
+        durability: "ephemeral";
+        durable: undefined;
+        data: import("effect/Schema").Struct<{}>;
+    }];
+};

package/dist/models-dev.js

@@ -0,0 +1,7 @@
+export * as ModelsDev from "./models-dev.js";
+import { ephemeral, inventory } from "./event.js";
+const Refreshed = ephemeral({
+    type: "models-dev.refreshed",
+    schema: {},
+});
+export const Event = { Refreshed, Definitions: inventory(Refreshed) };

package/dist/money.d.ts

@@ -0,0 +1,10 @@
+export * as Money from "./money.js";
+import { Schema } from "effect";
+export declare const USD: Schema.brand<Schema.Finite, "Money.USD"> & {
+    zero: number & import("effect/Brand").Brand<"Money.USD">;
+};
+export type USD = typeof USD.Type;
+export declare const USDPerMillionTokens: Schema.brand<Schema.Finite, "Money.USDPerMillionTokens"> & {
+    zero: number & import("effect/Brand").Brand<"Money.USDPerMillionTokens">;
+};
+export type USDPerMillionTokens = typeof USDPerMillionTokens.Type;

package/dist/money.js

@@ -0,0 +1,5 @@
+export * as Money from "./money.js";
+import { Schema } from "effect";
+import { statics } from "./schema.js";
+export const USD = Schema.Finite.pipe(Schema.brand("Money.USD"), Schema.annotate({ identifier: "Money.USD" }), statics((schema) => ({ zero: schema.make(0) })));
+export const USDPerMillionTokens = Schema.Finite.pipe(Schema.brand("Money.USDPerMillionTokens"), Schema.annotate({ identifier: "Money.USDPerMillionTokens" }), statics((schema) => ({ zero: schema.make(0) })));

package/dist/permission-saved.d.ts

@@ -0,0 +1,18 @@
+export * as PermissionSaved from "./permission-saved.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+};
+export type ID = typeof ID.Type;
+export declare const Info: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "PermissionSaved.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"PermissionSaved.ID">;
+    };
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly action: Schema.String;
+    readonly resource: Schema.String;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}

package/dist/permission-saved.js

@@ -0,0 +1,12 @@
+export * as PermissionSaved from "./permission-saved.js";
+import { Schema } from "effect";
+import { ascending } from "./identifier.js";
+import { ProjectID } from "./project-id.js";
+import { statics } from "./schema.js";
+export const ID = Schema.String.pipe(Schema.brand("PermissionSaved.ID"), statics((schema) => ({ create: () => schema.make("psv_" + ascending()) })));
+export const Info = Schema.Struct({
+    id: ID,
+    projectID: ProjectID,
+    action: Schema.String,
+    resource: Schema.String,
+}).annotate({ identifier: "PermissionSaved.Info" });

package/dist/permission-v1.d.ts

@@ -0,0 +1 @@
+export * from "./v1/permission.js";

package/dist/permission-v1.js

@@ -0,0 +1 @@
+export * from "./v1/permission.js";