@opencode-ai/schema 0.0.0-next-14659

package/dist/integration.d.ts

@@ -0,0 +1,572 @@
+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 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 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<{}>;
+    }> & {
+        data: Schema.Struct<{}>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "integration.updated";
+    };
+    ConnectionUpdated: 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<"integration.connection.updated">;
+        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 integrationID: Schema.brand<Schema.String, "Integration.ID">;
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "integration.connection.updated";
+    };
+    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<"integration.updated">;
+        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<{}>;
+    }> & {
+        data: Schema.Struct<{}>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "integration.updated";
+    }, 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<"integration.connection.updated">;
+        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 integrationID: Schema.brand<Schema.String, "Integration.ID">;
+        }>;
+    }> & {
+        data: Schema.Struct<{
+            readonly integrationID: Schema.brand<Schema.String, "Integration.ID">;
+        }>;
+        durable?: {
+            readonly version: number;
+            readonly aggregate: string;
+        } | undefined;
+        type: "integration.connection.updated";
+    }];
+};
+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

@@ -0,0 +1,93 @@
+export * as Integration from "./integration.js";
+import { Schema } from "effect";
+import { optional } from "./schema.js";
+import { define, 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 = define({
+    type: "integration.updated",
+    schema: {},
+});
+const ConnectionUpdated = define({
+    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

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