@opencode-ai/schema 0.0.0-next-14855 → 0.0.0-reserved.0

package/dist/integration.d.ts

@@ -1,532 +0,0 @@
-export * as Integration from "./integration.js";
-import { Schema } from "effect";
-export declare const ID: Schema.brand<Schema.String, "Integration.ID">;
-export type ID = typeof ID.Type;
-export declare const MethodID: Schema.brand<Schema.String, "Integration.MethodID">;
-export type MethodID = typeof MethodID.Type;
-export interface When extends Schema.Schema.Type<typeof When> {
-}
-export declare const When: Schema.Struct<{
-    readonly key: Schema.String;
-    readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-    readonly value: Schema.String;
-}>;
-export interface TextPrompt extends Schema.Schema.Type<typeof TextPrompt> {
-}
-export declare const TextPrompt: Schema.Struct<{
-    readonly type: Schema.Literal<"text">;
-    readonly key: Schema.String;
-    readonly message: Schema.String;
-    readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-        readonly value: Schema.String;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-        readonly value: Schema.String;
-    }>>, never, never>;
-}>;
-export interface SelectPrompt extends Schema.Schema.Type<typeof SelectPrompt> {
-}
-export declare const SelectPrompt: Schema.Struct<{
-    readonly type: Schema.Literal<"select">;
-    readonly key: Schema.String;
-    readonly message: Schema.String;
-    readonly options: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.String;
-        readonly value: Schema.String;
-        readonly hint: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    }>>;
-    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-        readonly value: Schema.String;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-        readonly value: Schema.String;
-    }>>, never, never>;
-}>;
-export declare const Prompt: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"text">;
-    readonly key: Schema.String;
-    readonly message: Schema.String;
-    readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-        readonly value: Schema.String;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-        readonly value: Schema.String;
-    }>>, never, never>;
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"select">;
-    readonly key: Schema.String;
-    readonly message: Schema.String;
-    readonly options: Schema.$Array<Schema.Struct<{
-        readonly label: Schema.String;
-        readonly value: Schema.String;
-        readonly hint: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    }>>;
-    readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-        readonly value: Schema.String;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly key: Schema.String;
-        readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-        readonly value: Schema.String;
-    }>>, never, never>;
-}>]>;
-export type Prompt = typeof Prompt.Type;
-export interface OAuthMethod extends Schema.Schema.Type<typeof OAuthMethod> {
-}
-export declare const OAuthMethod: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Integration.MethodID">;
-    readonly type: Schema.Literal<"oauth">;
-    readonly label: Schema.String;
-    readonly prompts: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"text">;
-        readonly key: Schema.String;
-        readonly message: Schema.String;
-        readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>, never, never>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"select">;
-        readonly key: Schema.String;
-        readonly message: Schema.String;
-        readonly options: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.String;
-            readonly value: Schema.String;
-            readonly hint: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        }>>;
-        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>, never, never>;
-    }>]>>>>, Schema.optionalKey<Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"text">;
-        readonly key: Schema.String;
-        readonly message: Schema.String;
-        readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>, never, never>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"select">;
-        readonly key: Schema.String;
-        readonly message: Schema.String;
-        readonly options: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.String;
-            readonly value: Schema.String;
-            readonly hint: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        }>>;
-        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>, never, never>;
-    }>]>>>, never, never>;
-}>;
-export interface KeyMethod extends Schema.Schema.Type<typeof KeyMethod> {
-}
-export declare const KeyMethod: Schema.Struct<{
-    readonly type: Schema.Literal<"key">;
-    readonly label: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>;
-export interface EnvMethod extends Schema.Schema.Type<typeof EnvMethod> {
-}
-export declare const EnvMethod: Schema.Struct<{
-    readonly type: Schema.Literal<"env">;
-    readonly names: Schema.$Array<Schema.String>;
-}>;
-export declare const Method: Schema.Union<readonly [Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Integration.MethodID">;
-    readonly type: Schema.Literal<"oauth">;
-    readonly label: Schema.String;
-    readonly prompts: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"text">;
-        readonly key: Schema.String;
-        readonly message: Schema.String;
-        readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>, never, never>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"select">;
-        readonly key: Schema.String;
-        readonly message: Schema.String;
-        readonly options: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.String;
-            readonly value: Schema.String;
-            readonly hint: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        }>>;
-        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>, never, never>;
-    }>]>>>>, Schema.optionalKey<Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"text">;
-        readonly key: Schema.String;
-        readonly message: Schema.String;
-        readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>, never, never>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"select">;
-        readonly key: Schema.String;
-        readonly message: Schema.String;
-        readonly options: Schema.$Array<Schema.Struct<{
-            readonly label: Schema.String;
-            readonly value: Schema.String;
-            readonly hint: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        }>>;
-        readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly key: Schema.String;
-            readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-            readonly value: Schema.String;
-        }>>, never, never>;
-    }>]>>>, never, never>;
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"key">;
-    readonly label: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"env">;
-    readonly names: Schema.$Array<Schema.String>;
-}>]>;
-export type Method = typeof Method.Type;
-export declare const Inputs: Schema.$Record<Schema.String, Schema.String>;
-export type Inputs = typeof Inputs.Type;
-export declare const Event: {
-    Updated: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, 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 type: Schema.Literal<"integration.updated">;
-        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<{}>;
-    }> & {
-        type: "integration.updated";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{}>;
-    };
-    ConnectionUpdated: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, 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 type: Schema.Literal<"integration.connection.updated">;
-        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 integrationID: Schema.brand<Schema.String, "Integration.ID">;
-        }>;
-    }> & {
-        type: "integration.connection.updated";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
-        }>;
-    };
-    Definitions: readonly [Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, 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 type: Schema.Literal<"integration.updated">;
-        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<{}>;
-    }> & {
-        type: "integration.updated";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{}>;
-    }, Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Event.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Event.ID">;
-        };
-        readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, 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 type: Schema.Literal<"integration.connection.updated">;
-        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 integrationID: Schema.brand<Schema.String, "Integration.ID">;
-        }>;
-    }> & {
-        type: "integration.connection.updated";
-        durability: "ephemeral";
-        durable: undefined;
-        data: Schema.Struct<{
-            readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
-        }>;
-    }];
-};
-export interface Ref extends Schema.Schema.Type<typeof Ref> {
-}
-export declare const Ref: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Integration.ID">;
-    readonly name: Schema.String;
-}>;
-declare const Info_base: Schema.Class<Info, Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "Integration.ID">;
-    readonly name: Schema.String;
-    readonly methods: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Integration.MethodID">;
-        readonly type: Schema.Literal<"oauth">;
-        readonly label: Schema.String;
-        readonly prompts: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"text">;
-            readonly key: Schema.String;
-            readonly message: Schema.String;
-            readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly key: Schema.String;
-                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-                readonly value: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly key: Schema.String;
-                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-                readonly value: Schema.String;
-            }>>, never, never>;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"select">;
-            readonly key: Schema.String;
-            readonly message: Schema.String;
-            readonly options: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.String;
-                readonly value: Schema.String;
-                readonly hint: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>>;
-            readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly key: Schema.String;
-                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-                readonly value: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly key: Schema.String;
-                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-                readonly value: Schema.String;
-            }>>, never, never>;
-        }>]>>>>, Schema.optionalKey<Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"text">;
-            readonly key: Schema.String;
-            readonly message: Schema.String;
-            readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly key: Schema.String;
-                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-                readonly value: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly key: Schema.String;
-                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-                readonly value: Schema.String;
-            }>>, never, never>;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"select">;
-            readonly key: Schema.String;
-            readonly message: Schema.String;
-            readonly options: Schema.$Array<Schema.Struct<{
-                readonly label: Schema.String;
-                readonly value: Schema.String;
-                readonly hint: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-            }>>;
-            readonly when: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-                readonly key: Schema.String;
-                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-                readonly value: Schema.String;
-            }>>>, Schema.optionalKey<Schema.Struct<{
-                readonly key: Schema.String;
-                readonly op: Schema.Literals<readonly ["eq", "neq"]>;
-                readonly value: Schema.String;
-            }>>, never, never>;
-        }>]>>>, never, never>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"key">;
-        readonly label: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"env">;
-        readonly names: Schema.$Array<Schema.String>;
-    }>]>>;
-    readonly connections: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly type: Schema.Literal<"credential">;
-        readonly id: Schema.brand<Schema.String, "Credential.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Credential.ID">;
-        };
-        readonly label: Schema.String;
-    }>, Schema.Struct<{
-        readonly type: Schema.Literal<"env">;
-        readonly name: Schema.String;
-    }>]>>;
-}>, {}>;
-export declare class Info extends Info_base {
-}
-export declare const AttemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
-    create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
-};
-export type AttemptID = typeof AttemptID.Type;
-declare const Attempt_base: Schema.Class<Attempt, Schema.Struct<{
-    readonly attemptID: Schema.brand<Schema.String, "Integration.AttemptID"> & {
-        create: () => string & import("effect/Brand").Brand<"Integration.AttemptID">;
-    };
-    readonly url: Schema.String;
-    readonly instructions: Schema.String;
-    readonly mode: Schema.Literals<readonly ["auto", "code"]>;
-    readonly time: Schema.Struct<{
-        readonly created: Schema.Number;
-        readonly expires: Schema.Number;
-    }>;
-}>, {}>;
-export declare class Attempt extends Attempt_base {
-}
-export declare const AttemptStatus: Schema.Union<readonly [Schema.Struct<{
-    readonly status: Schema.Literal<"pending">;
-    readonly time: Schema.Struct<{
-        readonly created: Schema.Number;
-        readonly expires: Schema.Number;
-    }>;
-}>, Schema.Struct<{
-    readonly status: Schema.Literal<"complete">;
-    readonly time: Schema.Struct<{
-        readonly created: Schema.Number;
-        readonly expires: Schema.Number;
-    }>;
-}>, Schema.Struct<{
-    readonly status: Schema.Literal<"failed">;
-    readonly message: Schema.String;
-    readonly time: Schema.Struct<{
-        readonly created: Schema.Number;
-        readonly expires: Schema.Number;
-    }>;
-}>, Schema.Struct<{
-    readonly status: Schema.Literal<"expired">;
-    readonly time: Schema.Struct<{
-        readonly created: Schema.Number;
-        readonly expires: Schema.Number;
-    }>;
-}>]>;
-export type AttemptStatus = typeof AttemptStatus.Type;

package/dist/integration.js

@@ -1,93 +0,0 @@
-export * as Integration from "./integration.js";
-import { Schema } from "effect";
-import { optional } from "./schema.js";
-import { ephemeral, inventory } from "./event.js";
-import { Connection } from "./connection.js";
-import { ascending } from "./identifier.js";
-import { statics } from "./schema.js";
-import { IntegrationID, IntegrationMethodID } from "./integration-id.js";
-export const ID = IntegrationID;
-export const MethodID = IntegrationMethodID;
-export const When = Schema.Struct({
-    key: Schema.String,
-    op: Schema.Literals(["eq", "neq"]),
-    value: Schema.String,
-}).annotate({ identifier: "Integration.When" });
-export const TextPrompt = Schema.Struct({
-    type: Schema.Literal("text"),
-    key: Schema.String,
-    message: Schema.String,
-    placeholder: optional(Schema.String),
-    when: optional(When),
-}).annotate({ identifier: "Integration.TextPrompt" });
-export const SelectPrompt = Schema.Struct({
-    type: Schema.Literal("select"),
-    key: Schema.String,
-    message: Schema.String,
-    options: Schema.Array(Schema.Struct({
-        label: Schema.String,
-        value: Schema.String,
-        hint: optional(Schema.String),
-    })),
-    when: optional(When),
-}).annotate({ identifier: "Integration.SelectPrompt" });
-export const Prompt = Schema.Union([TextPrompt, SelectPrompt]).pipe(Schema.toTaggedUnion("type"));
-export const OAuthMethod = Schema.Struct({
-    id: MethodID,
-    type: Schema.Literal("oauth"),
-    label: Schema.String,
-    prompts: optional(Schema.Array(Prompt)),
-}).annotate({ identifier: "Integration.OAuthMethod" });
-export const KeyMethod = Schema.Struct({
-    type: Schema.Literal("key"),
-    label: optional(Schema.String),
-}).annotate({ identifier: "Integration.KeyMethod" });
-export const EnvMethod = Schema.Struct({
-    type: Schema.Literal("env"),
-    names: Schema.Array(Schema.String),
-}).annotate({ identifier: "Integration.EnvMethod" });
-export const Method = Schema.Union([OAuthMethod, KeyMethod, EnvMethod])
-    .pipe(Schema.toTaggedUnion("type"))
-    .annotate({ identifier: "Integration.Method" });
-export const Inputs = Schema.Record(Schema.String, Schema.String).annotate({ identifier: "Integration.Inputs" });
-const Updated = ephemeral({
-    type: "integration.updated",
-    schema: {},
-});
-const ConnectionUpdated = ephemeral({
-    type: "integration.connection.updated",
-    schema: { integrationID: ID },
-});
-export const Event = { Updated, ConnectionUpdated, Definitions: inventory(Updated, ConnectionUpdated) };
-export const Ref = Schema.Struct({
-    id: ID,
-    name: Schema.String,
-}).annotate({ identifier: "Integration.Ref" });
-export class Info extends Schema.Class("Integration.Info")({
-    id: ID,
-    name: Schema.String,
-    methods: Schema.Array(Method),
-    connections: Schema.Array(Connection.Info),
-}) {
-}
-export const AttemptID = Schema.String.pipe(Schema.brand("Integration.AttemptID"), statics((schema) => ({ create: () => schema.make("con_" + ascending()) })));
-const AttemptTime = Schema.Struct({
-    created: Schema.Number,
-    expires: Schema.Number,
-});
-export class Attempt extends Schema.Class("Integration.Attempt")({
-    attemptID: AttemptID,
-    url: Schema.String,
-    instructions: Schema.String,
-    mode: Schema.Literals(["auto", "code"]),
-    time: AttemptTime,
-}) {
-}
-export const AttemptStatus = Schema.Union([
-    Schema.Struct({ status: Schema.Literal("pending"), time: AttemptTime }),
-    Schema.Struct({ status: Schema.Literal("complete"), time: AttemptTime }),
-    Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String, time: AttemptTime }),
-    Schema.Struct({ status: Schema.Literal("expired"), time: AttemptTime }),
-])
-    .pipe(Schema.toTaggedUnion("status"))
-    .annotate({ identifier: "Integration.AttemptStatus" });

package/dist/legacy-event.d.ts

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

package/dist/legacy-event.js

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

package/dist/llm.d.ts

@@ -1,28 +0,0 @@
-export * as LLM from "./llm.js";
-import { Schema } from "effect";
-export declare const ProviderMetadata: Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>;
-export type ProviderMetadata = Schema.Schema.Type<typeof ProviderMetadata>;
-export interface ToolTextContent extends Schema.Schema.Type<typeof ToolTextContent> {
-}
-export declare const ToolTextContent: Schema.Struct<{
-    readonly type: Schema.Literal<"text">;
-    readonly text: Schema.String;
-}>;
-export interface ToolFileContent extends Schema.Schema.Type<typeof ToolFileContent> {
-}
-export declare const ToolFileContent: Schema.Struct<{
-    readonly type: Schema.Literal<"file">;
-    readonly uri: Schema.String;
-    readonly mime: Schema.String;
-    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>;
-export declare const ToolContent: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"text">;
-    readonly text: Schema.String;
-}>, Schema.Struct<{
-    readonly type: Schema.Literal<"file">;
-    readonly uri: Schema.String;
-    readonly mime: Schema.String;
-    readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>]>;
-export type ToolContent = Schema.Schema.Type<typeof ToolContent>;