@kilocode/schema 0.0.0-stage → 0.0.0-v2-9

package/dist/kilocode/gateway.d.ts

@@ -0,0 +1,975 @@
+export * as KiloGatewayRpc from "./gateway.js";
+import { Schema } from "effect";
+export declare const Profile: Schema.Struct<{
+    readonly email: Schema.String;
+    readonly name: Schema.optional<Schema.String>;
+    readonly organizations: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly role: Schema.optional<Schema.String>;
+    }>>;
+    readonly hasPersonalAccount: Schema.Boolean;
+    /** The team that requests use now. `null` is the personal account. */
+    readonly organizationID: Schema.NullOr<Schema.String>;
+}>;
+export type Profile = typeof Profile.Type;
+export declare const AuthStatus: Schema.Struct<{
+    readonly authenticated: Schema.Boolean;
+    readonly organizationID: Schema.NullOr<Schema.String>;
+    readonly server: Schema.String;
+}>;
+export type AuthStatus = typeof AuthStatus.Type;
+export declare const Balance: Schema.Struct<{
+    readonly balance: Schema.NullOr<Schema.Number>;
+    readonly isDepleted: Schema.optional<Schema.Boolean>;
+}>;
+export type Balance = typeof Balance.Type;
+export declare const KiloPass: Schema.NullOr<Schema.Struct<{
+    readonly currentPeriodBaseCreditsUsd: Schema.Number;
+    readonly currentPeriodUsageUsd: Schema.Number;
+    readonly currentPeriodBonusCreditsUsd: Schema.Number;
+    readonly nextBillingAt: Schema.NullOr<Schema.String>;
+}>>;
+export type KiloPass = typeof KiloPass.Type;
+export declare const ByokEntry: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly provider_id: Schema.String;
+    readonly management_source: Schema.Literals<readonly ["user", "coding_plan"]>;
+    readonly is_enabled: Schema.Boolean;
+}>;
+export type ByokEntry = typeof ByokEntry.Type;
+export declare const CodingPlanSubscription: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly planId: Schema.String;
+    readonly planName: Schema.String;
+    readonly providerName: Schema.String;
+    readonly providerId: Schema.String;
+    readonly canQueryUsage: Schema.Boolean;
+    readonly hasInstalledByokKey: Schema.Boolean;
+    readonly status: Schema.Literals<readonly ["active", "past_due", "canceled"]>;
+    readonly cancelAtPeriodEnd: Schema.Boolean;
+}>;
+export type CodingPlanSubscription = typeof CodingPlanSubscription.Type;
+export declare const CodingPlanUsage: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<1>;
+    readonly fetchedAt: Schema.String;
+    readonly subscription: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly planName: Schema.String;
+        readonly providerId: Schema.String;
+        readonly providerName: Schema.String;
+        readonly windows: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly remainingPercent: Schema.Number;
+            readonly resetsAt: Schema.String;
+            readonly startsAt: Schema.optional<Schema.String>;
+            readonly period: Schema.Struct<{
+                readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+                readonly value: Schema.Number;
+            }>;
+        }>>;
+    }>;
+}>;
+export type CodingPlanUsage = typeof CodingPlanUsage.Type;
+export declare const OrganizationMode: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly organization_id: Schema.String;
+    readonly name: Schema.String;
+    readonly slug: Schema.String;
+    readonly created_by: Schema.String;
+    readonly created_at: Schema.String;
+    readonly updated_at: Schema.String;
+    readonly config: Schema.Struct<{
+        readonly roleDefinition: Schema.optional<Schema.String>;
+        readonly whenToUse: Schema.optional<Schema.String>;
+        readonly description: Schema.optional<Schema.String>;
+        readonly customInstructions: Schema.optional<Schema.String>;
+        readonly groups: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Tuple<readonly [Schema.String, Schema.Struct<{
+            readonly fileRegex: Schema.optional<Schema.String>;
+            readonly description: Schema.optional<Schema.String>;
+        }>]>]>>>;
+    }>;
+}>;
+export type OrganizationMode = typeof OrganizationMode.Type;
+export declare const Notification: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly title: Schema.String;
+    readonly message: Schema.String;
+    readonly action: Schema.optional<Schema.Struct<{
+        readonly actionText: Schema.String;
+        readonly actionURL: Schema.String;
+    }>>;
+    readonly showIn: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly suggestModelId: Schema.optional<Schema.String>;
+}>;
+export type Notification = typeof Notification.Type;
+export declare const ImageModel: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type ImageModel = typeof ImageModel.Type;
+export declare const TranscriptionModel: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+}>;
+export type TranscriptionModel = typeof TranscriptionModel.Type;
+export declare const EmbeddingCatalog: Schema.Struct<{
+    readonly defaultModel: Schema.String;
+    readonly models: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly dimension: Schema.Int;
+        readonly scoreThreshold: Schema.Finite;
+        readonly note: Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly aliases: Schema.$Record<Schema.String, Schema.String>;
+}>;
+export type EmbeddingCatalog = typeof EmbeddingCatalog.Type;
+export declare const FimTarget: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["kilo", "inception", "mistral"]>;
+    readonly model: Schema.String;
+    readonly url: Schema.optional<Schema.String>;
+}>;
+export declare const EditTarget: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["kilo", "inception"]>;
+    readonly model: Schema.String;
+    readonly url: Schema.String;
+}>;
+export declare const ModelEntry: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly recommended: Schema.optional<Schema.Boolean>;
+    readonly isFree: Schema.Boolean;
+    readonly recommendedIndex: Schema.optional<Schema.Number>;
+    readonly hasUserByokAvailable: Schema.optional<Schema.Boolean>;
+    readonly mayTrainOnYourPrompts: Schema.optional<Schema.Boolean>;
+    readonly autoRouting: Schema.optional<Schema.Struct<{
+        readonly models: Schema.$Array<Schema.String>;
+    }>>;
+    readonly terminalBench: Schema.optional<Schema.Struct<{
+        readonly overallScore: Schema.Number;
+        readonly avgAttemptCostUsd: Schema.Number;
+    }>>;
+    readonly description: Schema.optional<Schema.String>;
+    readonly reasoning: Schema.optional<Schema.Boolean>;
+    readonly family: Schema.optional<Schema.String>;
+    readonly aiSDKProvider: Schema.optional<Schema.String>;
+}>;
+export type ModelEntry = typeof ModelEntry.Type;
+export declare const CatalogFailure: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["unauthorized", "network", "schema", "http", "organization_missing"]>;
+    readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>;
+export interface CatalogFailure extends Schema.Schema.Type<typeof CatalogFailure> {
+}
+export declare const SessionMetadata: Schema.Struct<{
+    readonly routedModelID: Schema.optional<Schema.String>;
+    readonly vercelID: Schema.optional<Schema.String>;
+}>;
+export type SessionMetadata = typeof SessionMetadata.Type;
+export declare const PLATFORM_METADATA_KEY = "kilocode.platform";
+export declare const RouterEvalConfig: Schema.Struct<{
+    readonly server: Schema.String;
+    readonly organizationID: Schema.NullOr<Schema.String>;
+    readonly provider: Schema.String;
+    readonly model: Schema.String;
+    /** Config for the published CLI in the eval container. Has no credentials. */
+    readonly config: Schema.Unknown;
+    /** Credentials for the published CLI in the eval container. Secret. */
+    readonly auth: Schema.Unknown;
+}>;
+export type RouterEvalConfig = typeof RouterEvalConfig.Type;
+export declare const Definition: {
+    readonly id: "kilocode.gateway";
+    readonly methods: {
+        readonly authStatus: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly authenticated: boolean;
+                readonly organizationID: string | null;
+                readonly server: string;
+            }, {
+                readonly authenticated: boolean;
+                readonly organizationID: string | null;
+                readonly server: string;
+            }> & Schema.Struct<{
+                readonly authenticated: Schema.Boolean;
+                readonly organizationID: Schema.NullOr<Schema.String>;
+                readonly server: Schema.String;
+            }>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly profile: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly email: string;
+                readonly name?: string | undefined;
+                readonly organizations: readonly {
+                    readonly id: string;
+                    readonly name: string;
+                    readonly role?: string | undefined;
+                }[];
+                readonly hasPersonalAccount: boolean;
+                readonly organizationID: string | null;
+            }, {
+                readonly email: string;
+                readonly name?: string | undefined;
+                readonly organizations: readonly {
+                    readonly id: string;
+                    readonly name: string;
+                    readonly role?: string | undefined;
+                }[];
+                readonly hasPersonalAccount: boolean;
+                readonly organizationID: string | null;
+            }> & Schema.Struct<{
+                readonly email: Schema.String;
+                readonly name: Schema.optional<Schema.String>;
+                readonly organizations: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly name: Schema.String;
+                    readonly role: Schema.optional<Schema.String>;
+                }>>;
+                readonly hasPersonalAccount: Schema.Boolean;
+                /** The team that requests use now. `null` is the personal account. */
+                readonly organizationID: Schema.NullOr<Schema.String>;
+            }>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly balance: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly balance: number | null;
+                readonly isDepleted?: boolean | undefined;
+            }, {
+                readonly balance: number | null;
+                readonly isDepleted?: boolean | undefined;
+            }> & Schema.Struct<{
+                readonly balance: Schema.NullOr<Schema.Number>;
+                readonly isDepleted: Schema.optional<Schema.Boolean>;
+            }>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly kiloPass: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly currentPeriodBaseCreditsUsd: number;
+                readonly currentPeriodUsageUsd: number;
+                readonly currentPeriodBonusCreditsUsd: number;
+                readonly nextBillingAt: string | null;
+            } | null, {
+                readonly currentPeriodBaseCreditsUsd: number;
+                readonly currentPeriodUsageUsd: number;
+                readonly currentPeriodBonusCreditsUsd: number;
+                readonly nextBillingAt: string | null;
+            } | null> & Schema.NullOr<Schema.Struct<{
+                readonly currentPeriodBaseCreditsUsd: Schema.Number;
+                readonly currentPeriodUsageUsd: Schema.Number;
+                readonly currentPeriodBonusCreditsUsd: Schema.Number;
+                readonly nextBillingAt: Schema.NullOr<Schema.String>;
+            }>>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly byok: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<readonly {
+                readonly id: string;
+                readonly provider_id: string;
+                readonly management_source: "coding_plan" | "user";
+                readonly is_enabled: boolean;
+            }[], readonly {
+                readonly id: string;
+                readonly provider_id: string;
+                readonly management_source: "coding_plan" | "user";
+                readonly is_enabled: boolean;
+            }[]> & Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly provider_id: Schema.String;
+                readonly management_source: Schema.Literals<readonly ["user", "coding_plan"]>;
+                readonly is_enabled: Schema.Boolean;
+            }>>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly codingPlans: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<readonly {
+                readonly id: string;
+                readonly planId: string;
+                readonly planName: string;
+                readonly providerName: string;
+                readonly providerId: string;
+                readonly canQueryUsage: boolean;
+                readonly hasInstalledByokKey: boolean;
+                readonly status: "active" | "canceled" | "past_due";
+                readonly cancelAtPeriodEnd: boolean;
+            }[], readonly {
+                readonly id: string;
+                readonly planId: string;
+                readonly planName: string;
+                readonly providerName: string;
+                readonly providerId: string;
+                readonly canQueryUsage: boolean;
+                readonly hasInstalledByokKey: boolean;
+                readonly status: "active" | "canceled" | "past_due";
+                readonly cancelAtPeriodEnd: boolean;
+            }[]> & Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly planId: Schema.String;
+                readonly planName: Schema.String;
+                readonly providerName: Schema.String;
+                readonly providerId: Schema.String;
+                readonly canQueryUsage: Schema.Boolean;
+                readonly hasInstalledByokKey: Schema.Boolean;
+                readonly status: Schema.Literals<readonly ["active", "past_due", "canceled"]>;
+                readonly cancelAtPeriodEnd: Schema.Boolean;
+            }>>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly codingPlanUsage: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly subscriptionID: string;
+            }, {
+                readonly subscriptionID: string;
+            }> & Schema.Struct<{
+                readonly subscriptionID: Schema.String;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly schemaVersion: 1;
+                readonly fetchedAt: string;
+                readonly subscription: {
+                    readonly id: string;
+                    readonly planName: string;
+                    readonly providerId: string;
+                    readonly providerName: string;
+                    readonly windows: readonly {
+                        readonly id: string;
+                        readonly remainingPercent: number;
+                        readonly resetsAt: string;
+                        readonly startsAt?: string | undefined;
+                        readonly period: {
+                            readonly unit: "day" | "hour" | "month" | "week";
+                            readonly value: number;
+                        };
+                    }[];
+                };
+            }, {
+                readonly schemaVersion: 1;
+                readonly fetchedAt: string;
+                readonly subscription: {
+                    readonly id: string;
+                    readonly planName: string;
+                    readonly providerId: string;
+                    readonly providerName: string;
+                    readonly windows: readonly {
+                        readonly id: string;
+                        readonly remainingPercent: number;
+                        readonly resetsAt: string;
+                        readonly startsAt?: string | undefined;
+                        readonly period: {
+                            readonly unit: "day" | "hour" | "month" | "week";
+                            readonly value: number;
+                        };
+                    }[];
+                };
+            }> & Schema.Struct<{
+                readonly schemaVersion: Schema.Literal<1>;
+                readonly fetchedAt: Schema.String;
+                readonly subscription: Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly planName: Schema.String;
+                    readonly providerId: Schema.String;
+                    readonly providerName: Schema.String;
+                    readonly windows: Schema.$Array<Schema.Struct<{
+                        readonly id: Schema.String;
+                        readonly remainingPercent: Schema.Number;
+                        readonly resetsAt: Schema.String;
+                        readonly startsAt: Schema.optional<Schema.String>;
+                        readonly period: Schema.Struct<{
+                            readonly unit: Schema.Literals<readonly ["hour", "day", "week", "month"]>;
+                            readonly value: Schema.Number;
+                        }>;
+                    }>>;
+                }>;
+            }>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly "organization.set": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly organizationID: string | null;
+            }, {
+                readonly organizationID: string | null;
+            }> & Schema.Struct<{
+                readonly organizationID: Schema.NullOr<Schema.String>;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly modes: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<readonly {
+                readonly id: string;
+                readonly organization_id: string;
+                readonly name: string;
+                readonly slug: string;
+                readonly created_by: string;
+                readonly created_at: string;
+                readonly updated_at: string;
+                readonly config: {
+                    readonly roleDefinition?: string | undefined;
+                    readonly whenToUse?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly customInstructions?: string | undefined;
+                    readonly groups?: readonly (string | readonly [string, {
+                        readonly fileRegex?: string | undefined;
+                        readonly description?: string | undefined;
+                    }])[] | undefined;
+                };
+            }[], readonly {
+                readonly id: string;
+                readonly organization_id: string;
+                readonly name: string;
+                readonly slug: string;
+                readonly created_by: string;
+                readonly created_at: string;
+                readonly updated_at: string;
+                readonly config: {
+                    readonly roleDefinition?: string | undefined;
+                    readonly whenToUse?: string | undefined;
+                    readonly description?: string | undefined;
+                    readonly customInstructions?: string | undefined;
+                    readonly groups?: readonly (string | readonly [string, {
+                        readonly fileRegex?: string | undefined;
+                        readonly description?: string | undefined;
+                    }])[] | undefined;
+                };
+            }[]> & Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly organization_id: Schema.String;
+                readonly name: Schema.String;
+                readonly slug: Schema.String;
+                readonly created_by: Schema.String;
+                readonly created_at: Schema.String;
+                readonly updated_at: Schema.String;
+                readonly config: Schema.Struct<{
+                    readonly roleDefinition: Schema.optional<Schema.String>;
+                    readonly whenToUse: Schema.optional<Schema.String>;
+                    readonly description: Schema.optional<Schema.String>;
+                    readonly customInstructions: Schema.optional<Schema.String>;
+                    readonly groups: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Tuple<readonly [Schema.String, Schema.Struct<{
+                        readonly fileRegex: Schema.optional<Schema.String>;
+                        readonly description: Schema.optional<Schema.String>;
+                    }>]>]>>>;
+                }>;
+            }>>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly notifications: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<readonly {
+                readonly id: string;
+                readonly title: string;
+                readonly message: string;
+                readonly action?: {
+                    readonly actionText: string;
+                    readonly actionURL: string;
+                } | undefined;
+                readonly showIn?: readonly string[] | undefined;
+                readonly suggestModelId?: string | undefined;
+            }[], readonly {
+                readonly id: string;
+                readonly title: string;
+                readonly message: string;
+                readonly action?: {
+                    readonly actionText: string;
+                    readonly actionURL: string;
+                } | undefined;
+                readonly showIn?: readonly string[] | undefined;
+                readonly suggestModelId?: string | undefined;
+            }[]> & Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly title: Schema.String;
+                readonly message: Schema.String;
+                readonly action: Schema.optional<Schema.Struct<{
+                    readonly actionText: Schema.String;
+                    readonly actionURL: Schema.String;
+                }>>;
+                readonly showIn: Schema.optional<Schema.$Array<Schema.String>>;
+                readonly suggestModelId: Schema.optional<Schema.String>;
+            }>>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly models: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<readonly {
+                readonly id: string;
+                readonly name: string;
+                readonly recommended?: boolean | undefined;
+                readonly isFree: boolean;
+                readonly recommendedIndex?: number | undefined;
+                readonly hasUserByokAvailable?: boolean | undefined;
+                readonly mayTrainOnYourPrompts?: boolean | undefined;
+                readonly autoRouting?: {
+                    readonly models: readonly string[];
+                } | undefined;
+                readonly terminalBench?: {
+                    readonly overallScore: number;
+                    readonly avgAttemptCostUsd: number;
+                } | undefined;
+                readonly description?: string | undefined;
+                readonly reasoning?: boolean | undefined;
+                readonly family?: string | undefined;
+                readonly aiSDKProvider?: string | undefined;
+            }[], readonly {
+                readonly id: string;
+                readonly name: string;
+                readonly recommended?: boolean | undefined;
+                readonly isFree: boolean;
+                readonly recommendedIndex?: number | undefined;
+                readonly hasUserByokAvailable?: boolean | undefined;
+                readonly mayTrainOnYourPrompts?: boolean | undefined;
+                readonly autoRouting?: {
+                    readonly models: readonly string[];
+                } | undefined;
+                readonly terminalBench?: {
+                    readonly overallScore: number;
+                    readonly avgAttemptCostUsd: number;
+                } | undefined;
+                readonly description?: string | undefined;
+                readonly reasoning?: boolean | undefined;
+                readonly family?: string | undefined;
+                readonly aiSDKProvider?: string | undefined;
+            }[]> & Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly name: Schema.String;
+                readonly recommended: Schema.optional<Schema.Boolean>;
+                readonly isFree: Schema.Boolean;
+                readonly recommendedIndex: Schema.optional<Schema.Number>;
+                readonly hasUserByokAvailable: Schema.optional<Schema.Boolean>;
+                readonly mayTrainOnYourPrompts: Schema.optional<Schema.Boolean>;
+                readonly autoRouting: Schema.optional<Schema.Struct<{
+                    readonly models: Schema.$Array<Schema.String>;
+                }>>;
+                readonly terminalBench: Schema.optional<Schema.Struct<{
+                    readonly overallScore: Schema.Number;
+                    readonly avgAttemptCostUsd: Schema.Number;
+                }>>;
+                readonly description: Schema.optional<Schema.String>;
+                readonly reasoning: Schema.optional<Schema.Boolean>;
+                readonly family: Schema.optional<Schema.String>;
+                readonly aiSDKProvider: Schema.optional<Schema.String>;
+            }>>;
+            readonly errors: {
+                readonly unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                readonly failed: import("effect/StandardSchema").StandardSchemaV1<{
+                    readonly kind: "http" | "network" | "organization_missing" | "schema" | "unauthorized";
+                    readonly status?: number | undefined;
+                }, {
+                    readonly kind: "http" | "network" | "organization_missing" | "schema" | "unauthorized";
+                    readonly status?: number | undefined;
+                }> & Schema.Struct<{
+                    readonly kind: Schema.Literals<readonly ["unauthorized", "network", "schema", "http", "organization_missing"]>;
+                    readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+                }>;
+            };
+        };
+        readonly "models.images": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<readonly {
+                readonly id: string;
+                readonly name: string;
+                readonly description?: string | undefined;
+            }[], readonly {
+                readonly id: string;
+                readonly name: string;
+                readonly description?: string | undefined;
+            }[]> & Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly name: Schema.String;
+                readonly description: Schema.optional<Schema.String>;
+            }>>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly "models.transcriptions": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<readonly {
+                readonly id: string;
+                readonly name: string;
+            }[], readonly {
+                readonly id: string;
+                readonly name: string;
+            }[]> & Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly name: Schema.String;
+            }>>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly "models.embeddings": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly defaultModel: string;
+                readonly models: readonly {
+                    readonly id: string;
+                    readonly name: string;
+                    readonly dimension: number;
+                    readonly scoreThreshold: number;
+                    readonly note?: string | undefined;
+                }[];
+                readonly aliases: {
+                    readonly [x: string]: string;
+                };
+            }, {
+                readonly defaultModel: string;
+                readonly models: readonly {
+                    readonly id: string;
+                    readonly name: string;
+                    readonly dimension: number;
+                    readonly scoreThreshold: number;
+                    readonly note?: string | undefined;
+                }[];
+                readonly aliases: {
+                    readonly [x: string]: string;
+                };
+            }> & Schema.Struct<{
+                readonly defaultModel: Schema.String;
+                readonly models: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly name: Schema.String;
+                    readonly dimension: Schema.Int;
+                    readonly scoreThreshold: Schema.Finite;
+                    readonly note: Schema.optionalKey<Schema.String>;
+                }>>;
+                readonly aliases: Schema.$Record<Schema.String, Schema.String>;
+            }>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly "autocomplete.fimTarget": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly provider?: string | undefined;
+                readonly model?: string | undefined;
+            }, {
+                readonly provider?: string | undefined;
+                readonly model?: string | undefined;
+            }> & Schema.Struct<{
+                readonly provider: Schema.optional<Schema.String>;
+                readonly model: Schema.optional<Schema.String>;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly provider: "inception" | "kilo" | "mistral";
+                readonly model: string;
+                readonly url?: string | undefined;
+            }, {
+                readonly provider: "inception" | "kilo" | "mistral";
+                readonly model: string;
+                readonly url?: string | undefined;
+            }> & Schema.Struct<{
+                readonly provider: Schema.Literals<readonly ["kilo", "inception", "mistral"]>;
+                readonly model: Schema.String;
+                readonly url: Schema.optional<Schema.String>;
+            }>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly "autocomplete.editTarget": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly provider?: string | undefined;
+                readonly model?: string | undefined;
+            }, {
+                readonly provider?: string | undefined;
+                readonly model?: string | undefined;
+            }> & Schema.Struct<{
+                readonly provider: Schema.optional<Schema.String>;
+                readonly model: Schema.optional<Schema.String>;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly provider: "inception" | "kilo";
+                readonly model: string;
+                readonly url: string;
+            }, {
+                readonly provider: "inception" | "kilo";
+                readonly model: string;
+                readonly url: string;
+            }> & Schema.Struct<{
+                readonly provider: Schema.Literals<readonly ["kilo", "inception"]>;
+                readonly model: Schema.String;
+                readonly url: Schema.String;
+            }>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly "session.metadata": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+            }, {
+                readonly sessionID: string;
+            }> & Schema.Struct<{
+                readonly sessionID: Schema.String;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly routedModelID?: string | undefined;
+                readonly vercelID?: string | undefined;
+            }, {
+                readonly routedModelID?: string | undefined;
+                readonly vercelID?: string | undefined;
+            }> & Schema.Struct<{
+                readonly routedModelID: Schema.optional<Schema.String>;
+                readonly vercelID: Schema.optional<Schema.String>;
+            }>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        readonly "routers.list": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<unknown, unknown> & Schema.Unknown;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                router: import("effect/StandardSchema").StandardSchemaV1<{
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }, {
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }> & Schema.Struct<{
+                    readonly code: Schema.String;
+                    readonly retryAt: Schema.optional<Schema.String>;
+                }>;
+            };
+        };
+        readonly "routers.add": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly router: string;
+                readonly model: string;
+            }, {
+                readonly router: string;
+                readonly model: string;
+            }> & Schema.Struct<{
+                /** Router model ID or slug, as `kilo auto router` accepts it. */
+                readonly router: Schema.String;
+                /** `<provider>/<model>` of a catalog model. */
+                readonly model: Schema.String;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<unknown, unknown> & Schema.Unknown;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                router: import("effect/StandardSchema").StandardSchemaV1<{
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }, {
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }> & Schema.Struct<{
+                    readonly code: Schema.String;
+                    readonly retryAt: Schema.optional<Schema.String>;
+                }>;
+            };
+        };
+        readonly "routers.remove": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly router: string;
+                readonly model: string;
+            }, {
+                readonly router: string;
+                readonly model: string;
+            }> & Schema.Struct<{
+                /** Router model ID or slug, as `kilo auto router` accepts it. */
+                readonly router: Schema.String;
+                /** `<provider>/<model>` of a catalog model. */
+                readonly model: Schema.String;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<unknown, unknown> & Schema.Unknown;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                router: import("effect/StandardSchema").StandardSchemaV1<{
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }, {
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }> & Schema.Struct<{
+                    readonly code: Schema.String;
+                    readonly retryAt: Schema.optional<Schema.String>;
+                }>;
+            };
+        };
+        readonly "routers.evalPlan": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly routerID: string;
+            }, {
+                readonly routerID: string;
+            }> & Schema.Struct<{
+                readonly routerID: Schema.String;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<unknown, unknown> & Schema.Unknown;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                router: import("effect/StandardSchema").StandardSchemaV1<{
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }, {
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }> & Schema.Struct<{
+                    readonly code: Schema.String;
+                    readonly retryAt: Schema.optional<Schema.String>;
+                }>;
+            };
+        };
+        readonly "routers.evalCase": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly routerID: string;
+                readonly caseID: string;
+            }, {
+                readonly routerID: string;
+                readonly caseID: string;
+            }> & Schema.Struct<{
+                readonly routerID: Schema.String;
+                readonly caseID: Schema.String;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<unknown, unknown> & Schema.Unknown;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                router: import("effect/StandardSchema").StandardSchemaV1<{
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }, {
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }> & Schema.Struct<{
+                    readonly code: Schema.String;
+                    readonly retryAt: Schema.optional<Schema.String>;
+                }>;
+            };
+        };
+        readonly "routers.evalConfig": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly entry: unknown;
+            }, {
+                readonly entry: unknown;
+            }> & Schema.Struct<{
+                readonly entry: Schema.Unknown;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly server: string;
+                readonly organizationID: string | null;
+                readonly provider: string;
+                readonly model: string;
+                readonly config: unknown;
+                readonly auth: unknown;
+            }, {
+                readonly server: string;
+                readonly organizationID: string | null;
+                readonly provider: string;
+                readonly model: string;
+                readonly config: unknown;
+                readonly auth: unknown;
+            }> & Schema.Struct<{
+                readonly server: Schema.String;
+                readonly organizationID: Schema.NullOr<Schema.String>;
+                readonly provider: Schema.String;
+                readonly model: Schema.String;
+                /** Config for the published CLI in the eval container. Has no credentials. */
+                readonly config: Schema.Unknown;
+                /** Credentials for the published CLI in the eval container. Secret. */
+                readonly auth: Schema.Unknown;
+            }>;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                router: import("effect/StandardSchema").StandardSchemaV1<{
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }, {
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }> & Schema.Struct<{
+                    readonly code: Schema.String;
+                    readonly retryAt: Schema.optional<Schema.String>;
+                }>;
+            };
+        };
+        readonly "routers.evalResult": {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly result: unknown;
+            }, {
+                readonly result: unknown;
+            }> & Schema.Struct<{
+                readonly result: Schema.Unknown;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<unknown, unknown> & Schema.Unknown;
+            errors: {
+                unauthorized: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                router: import("effect/StandardSchema").StandardSchemaV1<{
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }, {
+                    readonly code: string;
+                    readonly retryAt?: string | undefined;
+                }> & Schema.Struct<{
+                    readonly code: Schema.String;
+                    readonly retryAt: Schema.optional<Schema.String>;
+                }>;
+            };
+        };
+    };
+    readonly events: {
+        organization: {
+            schema: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly organizationID: string | null;
+            }, {
+                readonly organizationID: string | null;
+            }> & Schema.Struct<{
+                readonly organizationID: Schema.NullOr<Schema.String>;
+            }>;
+        };
+    };
+};