@llmops/core 0.1.0-beta.8 → 0.1.1-beta.1

package/dist/index-Ddhbb3O5.d.mts

@@ -0,0 +1,883 @@
+import { ColumnType, Generated, Kysely, MssqlDialect, MysqlDialect, PostgresDialect, SqliteDialect } from "kysely";
+import * as zod0 from "zod";
+import { z } from "zod";
+
+//#region src/db/schema.d.ts
+declare const configsSchema: z.ZodObject<{
+  slug: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  id: z.ZodString;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+}, z.core.$strip>;
+declare const variantsSchema: z.ZodObject<{
+  name: z.ZodString;
+  id: z.ZodString;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+}, z.core.$strip>;
+declare const variantVersionsSchema: z.ZodObject<{
+  variantId: z.ZodString;
+  version: z.ZodNumber;
+  provider: z.ZodString;
+  modelName: z.ZodString;
+  jsonData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  id: z.ZodString;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+}, z.core.$strip>;
+declare const environmentsSchema: z.ZodObject<{
+  name: z.ZodString;
+  slug: z.ZodString;
+  isProd: z.ZodDefault<z.ZodBoolean>;
+  id: z.ZodString;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+}, z.core.$strip>;
+declare const environmentSecretsSchema: z.ZodObject<{
+  environmentId: z.ZodString;
+  keyName: z.ZodString;
+  keyValue: z.ZodString;
+  id: z.ZodString;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+}, z.core.$strip>;
+declare const configVariantsSchema: z.ZodObject<{
+  configId: z.ZodString;
+  variantId: z.ZodString;
+  id: z.ZodString;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+}, z.core.$strip>;
+declare const targetingRulesSchema: z.ZodObject<{
+  environmentId: z.ZodString;
+  configId: z.ZodString;
+  configVariantId: z.ZodString;
+  variantVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  weight: z.ZodDefault<z.ZodNumber>;
+  priority: z.ZodDefault<z.ZodNumber>;
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  conditions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  id: z.ZodString;
+  createdAt: z.ZodDate;
+  updatedAt: z.ZodDate;
+}, z.core.$strip>;
+/**
+ * Zod inferred types (for runtime validation)
+ */
+type Config = z.infer<typeof configsSchema>;
+type Variant = z.infer<typeof variantsSchema>;
+type VariantVersion = z.infer<typeof variantVersionsSchema>;
+type Environment = z.infer<typeof environmentsSchema>;
+type EnvironmentSecret = z.infer<typeof environmentSecretsSchema>;
+type ConfigVariant = z.infer<typeof configVariantsSchema>;
+type TargetingRule = z.infer<typeof targetingRulesSchema>;
+/**
+ * Kysely Table Interfaces
+ * Derived from Zod schemas with proper column types
+ */
+interface BaseTable {
+  id: Generated<string>;
+  createdAt: ColumnType<Date, string | undefined, string | undefined>;
+  updatedAt: ColumnType<Date, string | undefined, string | undefined>;
+}
+interface ConfigsTable extends BaseTable {
+  slug: string;
+  name?: string;
+}
+interface VariantsTable extends BaseTable {
+  name: string;
+}
+interface VariantVersionsTable extends BaseTable {
+  variantId: string;
+  version: number;
+  provider: string;
+  modelName: string;
+  jsonData: ColumnType<Record<string, unknown>, string, string>;
+}
+interface EnvironmentsTable extends BaseTable {
+  name: string;
+  slug: string;
+  isProd: ColumnType<boolean, boolean | undefined, boolean | undefined>;
+}
+interface EnvironmentSecretsTable extends BaseTable {
+  environmentId: string;
+  keyName: string;
+  keyValue: string;
+}
+interface ConfigVariantsTable extends BaseTable {
+  configId: string;
+  variantId: string;
+}
+interface TargetingRulesTable extends BaseTable {
+  environmentId: string;
+  configId: string;
+  configVariantId: string;
+  variantVersionId: string | null;
+  weight: ColumnType<number, number | undefined, number | undefined>;
+  priority: ColumnType<number, number | undefined, number | undefined>;
+  enabled: ColumnType<boolean, boolean | undefined, boolean | undefined>;
+  conditions: ColumnType<Record<string, unknown>, string, string>;
+}
+/**
+ * Main Kysely Database interface
+ */
+interface Database {
+  configs: ConfigsTable;
+  variants: VariantsTable;
+  variant_versions: VariantVersionsTable;
+  environments: EnvironmentsTable;
+  environment_secrets: EnvironmentSecretsTable;
+  config_variants: ConfigVariantsTable;
+  targeting_rules: TargetingRulesTable;
+}
+/**
+ * Table names as a union type
+ */
+type TableName = keyof Database;
+/**
+ * Utility types for type-safe operations
+ */
+type Insertable<T extends TableName> = { [K in keyof Database[T]]: Database[T][K] extends ColumnType<infer _SelectType, infer InsertType, infer _UpdateType> ? InsertType : Database[T][K] extends Generated<infer _GeneratedType> ? never : Database[T][K] };
+type Selectable<T extends TableName> = { [K in keyof Database[T]]: Database[T][K] extends ColumnType<infer SelectType, infer _InsertType, infer _UpdateType> ? SelectType : Database[T][K] extends Generated<infer GeneratedType> ? GeneratedType : Database[T][K] };
+type Updateable<T extends TableName> = { [K in keyof Database[T]]?: Database[T][K] extends ColumnType<infer _SelectType, infer _InsertType, infer UpdateType> ? UpdateType : Database[T][K] extends Generated<infer _GeneratedType> ? never : Database[T][K] };
+/**
+ * Schema metadata for migrations
+ * Derived from Zod schemas
+ */
+declare const SCHEMA_METADATA: {
+  readonly tables: {
+    readonly configs: {
+      readonly order: 1;
+      readonly schema: z.ZodObject<{
+        slug: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+      }, z.core.$strip>;
+      readonly fields: {
+        readonly id: {
+          readonly type: "uuid";
+          readonly primaryKey: true;
+        };
+        readonly slug: {
+          readonly type: "text";
+          readonly unique: true;
+        };
+        readonly name: {
+          readonly type: "text";
+          readonly nullable: true;
+        };
+        readonly createdAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+        };
+        readonly updatedAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+          readonly onUpdate: "now()";
+        };
+      };
+    };
+    readonly variants: {
+      readonly order: 2;
+      readonly schema: z.ZodObject<{
+        name: z.ZodString;
+        id: z.ZodString;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+      }, z.core.$strip>;
+      readonly fields: {
+        readonly id: {
+          readonly type: "uuid";
+          readonly primaryKey: true;
+        };
+        readonly name: {
+          readonly type: "text";
+        };
+        readonly createdAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+        };
+        readonly updatedAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+          readonly onUpdate: "now()";
+        };
+      };
+    };
+    readonly variant_versions: {
+      readonly order: 3;
+      readonly schema: z.ZodObject<{
+        variantId: z.ZodString;
+        version: z.ZodNumber;
+        provider: z.ZodString;
+        modelName: z.ZodString;
+        jsonData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        id: z.ZodString;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+      }, z.core.$strip>;
+      readonly fields: {
+        readonly id: {
+          readonly type: "uuid";
+          readonly primaryKey: true;
+        };
+        readonly variantId: {
+          readonly type: "uuid";
+          readonly references: {
+            readonly table: "variants";
+            readonly column: "id";
+          };
+        };
+        readonly version: {
+          readonly type: "integer";
+        };
+        readonly provider: {
+          readonly type: "text";
+        };
+        readonly modelName: {
+          readonly type: "text";
+        };
+        readonly jsonData: {
+          readonly type: "jsonb";
+        };
+        readonly createdAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+        };
+        readonly updatedAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+          readonly onUpdate: "now()";
+        };
+      };
+      readonly uniqueConstraints: readonly [{
+        readonly columns: readonly ["variantId", "version"];
+      }];
+    };
+    readonly environments: {
+      readonly order: 4;
+      readonly schema: z.ZodObject<{
+        name: z.ZodString;
+        slug: z.ZodString;
+        isProd: z.ZodDefault<z.ZodBoolean>;
+        id: z.ZodString;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+      }, z.core.$strip>;
+      readonly fields: {
+        readonly id: {
+          readonly type: "uuid";
+          readonly primaryKey: true;
+        };
+        readonly name: {
+          readonly type: "text";
+        };
+        readonly slug: {
+          readonly type: "text";
+          readonly unique: true;
+        };
+        readonly isProd: {
+          readonly type: "boolean";
+          readonly default: false;
+        };
+        readonly createdAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+        };
+        readonly updatedAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+          readonly onUpdate: "now()";
+        };
+      };
+    };
+    readonly environment_secrets: {
+      readonly order: 5;
+      readonly schema: z.ZodObject<{
+        environmentId: z.ZodString;
+        keyName: z.ZodString;
+        keyValue: z.ZodString;
+        id: z.ZodString;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+      }, z.core.$strip>;
+      readonly fields: {
+        readonly id: {
+          readonly type: "uuid";
+          readonly primaryKey: true;
+        };
+        readonly environmentId: {
+          readonly type: "uuid";
+          readonly references: {
+            readonly table: "environments";
+            readonly column: "id";
+          };
+        };
+        readonly keyName: {
+          readonly type: "text";
+        };
+        readonly keyValue: {
+          readonly type: "text";
+        };
+        readonly createdAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+        };
+        readonly updatedAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+          readonly onUpdate: "now()";
+        };
+      };
+    };
+    readonly config_variants: {
+      readonly order: 6;
+      readonly schema: z.ZodObject<{
+        configId: z.ZodString;
+        variantId: z.ZodString;
+        id: z.ZodString;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+      }, z.core.$strip>;
+      readonly fields: {
+        readonly id: {
+          readonly type: "uuid";
+          readonly primaryKey: true;
+        };
+        readonly configId: {
+          readonly type: "uuid";
+          readonly references: {
+            readonly table: "configs";
+            readonly column: "id";
+          };
+        };
+        readonly variantId: {
+          readonly type: "uuid";
+          readonly references: {
+            readonly table: "variants";
+            readonly column: "id";
+          };
+        };
+        readonly createdAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+        };
+        readonly updatedAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+          readonly onUpdate: "now()";
+        };
+      };
+    };
+    readonly targeting_rules: {
+      readonly order: 7;
+      readonly schema: z.ZodObject<{
+        environmentId: z.ZodString;
+        configId: z.ZodString;
+        configVariantId: z.ZodString;
+        variantVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        priority: z.ZodDefault<z.ZodNumber>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        conditions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        id: z.ZodString;
+        createdAt: z.ZodDate;
+        updatedAt: z.ZodDate;
+      }, z.core.$strip>;
+      readonly fields: {
+        readonly id: {
+          readonly type: "uuid";
+          readonly primaryKey: true;
+        };
+        readonly environmentId: {
+          readonly type: "uuid";
+          readonly references: {
+            readonly table: "environments";
+            readonly column: "id";
+          };
+        };
+        readonly configId: {
+          readonly type: "uuid";
+          readonly references: {
+            readonly table: "configs";
+            readonly column: "id";
+          };
+        };
+        readonly configVariantId: {
+          readonly type: "uuid";
+          readonly references: {
+            readonly table: "config_variants";
+            readonly column: "id";
+          };
+        };
+        readonly variantVersionId: {
+          readonly type: "uuid";
+          readonly nullable: true;
+          readonly references: {
+            readonly table: "variant_versions";
+            readonly column: "id";
+          };
+        };
+        readonly weight: {
+          readonly type: "integer";
+          readonly default: 10000;
+        };
+        readonly priority: {
+          readonly type: "integer";
+          readonly default: 0;
+        };
+        readonly enabled: {
+          readonly type: "boolean";
+          readonly default: true;
+        };
+        readonly conditions: {
+          readonly type: "jsonb";
+          readonly default: "{}";
+        };
+        readonly createdAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+        };
+        readonly updatedAt: {
+          readonly type: "timestamp";
+          readonly default: "now()";
+          readonly onUpdate: "now()";
+        };
+      };
+    };
+  };
+};
+/**
+ * Export all Zod schemas for runtime validation
+ */
+declare const schemas: {
+  readonly configs: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+  }, z.core.$strip>;
+  readonly variants: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodString;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+  }, z.core.$strip>;
+  readonly variant_versions: z.ZodObject<{
+    variantId: z.ZodString;
+    version: z.ZodNumber;
+    provider: z.ZodString;
+    modelName: z.ZodString;
+    jsonData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    id: z.ZodString;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+  }, z.core.$strip>;
+  readonly environments: z.ZodObject<{
+    name: z.ZodString;
+    slug: z.ZodString;
+    isProd: z.ZodDefault<z.ZodBoolean>;
+    id: z.ZodString;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+  }, z.core.$strip>;
+  readonly environment_secrets: z.ZodObject<{
+    environmentId: z.ZodString;
+    keyName: z.ZodString;
+    keyValue: z.ZodString;
+    id: z.ZodString;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+  }, z.core.$strip>;
+  readonly config_variants: z.ZodObject<{
+    configId: z.ZodString;
+    variantId: z.ZodString;
+    id: z.ZodString;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+  }, z.core.$strip>;
+  readonly targeting_rules: z.ZodObject<{
+    environmentId: z.ZodString;
+    configId: z.ZodString;
+    configVariantId: z.ZodString;
+    variantVersionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    conditions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    id: z.ZodString;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+  }, z.core.$strip>;
+};
+//#endregion
+//#region src/db/validation.d.ts
+/**
+ * Validate data against table schema
+ * Useful for runtime validation before inserting/updating
+ */
+declare function validateTableData<T extends TableName>(table: T, data: unknown): zod0.ZodSafeParseSuccess<{
+  slug: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  name?: string | undefined;
+}> | zod0.ZodSafeParseError<{
+  slug: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  name?: string | undefined;
+}> | zod0.ZodSafeParseSuccess<{
+  name: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}> | zod0.ZodSafeParseError<{
+  name: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}> | zod0.ZodSafeParseSuccess<{
+  variantId: string;
+  version: number;
+  provider: string;
+  modelName: string;
+  jsonData: Record<string, unknown>;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}> | zod0.ZodSafeParseError<{
+  variantId: string;
+  version: number;
+  provider: string;
+  modelName: string;
+  jsonData: Record<string, unknown>;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}> | zod0.ZodSafeParseSuccess<{
+  environmentId: string;
+  keyName: string;
+  keyValue: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}> | zod0.ZodSafeParseError<{
+  environmentId: string;
+  keyName: string;
+  keyValue: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}> | zod0.ZodSafeParseSuccess<{
+  configId: string;
+  variantId: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}> | zod0.ZodSafeParseError<{
+  configId: string;
+  variantId: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}> | zod0.ZodSafeParseSuccess<{
+  environmentId: string;
+  configId: string;
+  configVariantId: string;
+  weight: number;
+  priority: number;
+  enabled: boolean;
+  conditions: Record<string, unknown>;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  variantVersionId?: string | null | undefined;
+}> | zod0.ZodSafeParseError<{
+  environmentId: string;
+  configId: string;
+  configVariantId: string;
+  weight: number;
+  priority: number;
+  enabled: boolean;
+  conditions: Record<string, unknown>;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  variantVersionId?: string | null | undefined;
+}>;
+/**
+ * Validate partial data (for updates)
+ */
+declare function validatePartialTableData<T extends TableName>(table: T, data: unknown): zod0.ZodSafeParseSuccess<{
+  name?: string | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+}> | zod0.ZodSafeParseError<{
+  name?: string | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+}> | zod0.ZodSafeParseSuccess<{
+  variantId?: string | undefined;
+  version?: number | undefined;
+  provider?: string | undefined;
+  modelName?: string | undefined;
+  jsonData?: Record<string, unknown> | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+}> | zod0.ZodSafeParseError<{
+  variantId?: string | undefined;
+  version?: number | undefined;
+  provider?: string | undefined;
+  modelName?: string | undefined;
+  jsonData?: Record<string, unknown> | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+}> | zod0.ZodSafeParseSuccess<{
+  environmentId?: string | undefined;
+  keyName?: string | undefined;
+  keyValue?: string | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+}> | zod0.ZodSafeParseError<{
+  environmentId?: string | undefined;
+  keyName?: string | undefined;
+  keyValue?: string | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+}> | zod0.ZodSafeParseSuccess<{
+  configId?: string | undefined;
+  variantId?: string | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+}> | zod0.ZodSafeParseError<{
+  configId?: string | undefined;
+  variantId?: string | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+}> | zod0.ZodSafeParseSuccess<{
+  environmentId?: string | undefined;
+  configId?: string | undefined;
+  configVariantId?: string | undefined;
+  variantVersionId?: string | null | undefined;
+  weight?: number | undefined;
+  priority?: number | undefined;
+  enabled?: boolean | undefined;
+  conditions?: Record<string, unknown> | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+}> | zod0.ZodSafeParseError<{
+  environmentId?: string | undefined;
+  configId?: string | undefined;
+  configVariantId?: string | undefined;
+  variantVersionId?: string | null | undefined;
+  weight?: number | undefined;
+  priority?: number | undefined;
+  enabled?: boolean | undefined;
+  conditions?: Record<string, unknown> | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+}>;
+/**
+ * Parse and validate data, throws on error
+ */
+declare function parseTableData<T extends TableName>(table: T, data: unknown): {
+  slug: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  name?: string | undefined;
+} | {
+  name: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+} | {
+  variantId: string;
+  version: number;
+  provider: string;
+  modelName: string;
+  jsonData: Record<string, unknown>;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+} | {
+  environmentId: string;
+  keyName: string;
+  keyValue: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+} | {
+  configId: string;
+  variantId: string;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+} | {
+  environmentId: string;
+  configId: string;
+  configVariantId: string;
+  weight: number;
+  priority: number;
+  enabled: boolean;
+  conditions: Record<string, unknown>;
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  variantVersionId?: string | null | undefined;
+};
+/**
+ * Parse partial data, throws on error
+ */
+declare function parsePartialTableData<T extends TableName>(table: T, data: unknown): {
+  name?: string | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+} | {
+  variantId?: string | undefined;
+  version?: number | undefined;
+  provider?: string | undefined;
+  modelName?: string | undefined;
+  jsonData?: Record<string, unknown> | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+} | {
+  environmentId?: string | undefined;
+  keyName?: string | undefined;
+  keyValue?: string | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+} | {
+  configId?: string | undefined;
+  variantId?: string | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+} | {
+  environmentId?: string | undefined;
+  configId?: string | undefined;
+  configVariantId?: string | undefined;
+  variantVersionId?: string | null | undefined;
+  weight?: number | undefined;
+  priority?: number | undefined;
+  enabled?: boolean | undefined;
+  conditions?: Record<string, unknown> | undefined;
+  id?: string | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+};
+//#endregion
+//#region src/db/migrations.d.ts
+type DatabaseType$1 = 'postgres' | 'mysql' | 'sqlite' | 'mssql';
+/**
+ * Options for migration operations
+ */
+interface MigrationOptions {
+  /**
+   * PostgreSQL schema name to use.
+   * If provided, the schema will be created if it doesn't exist.
+   */
+  schema?: string;
+}
+declare function matchType(columnDataType: string, fieldType: string, dbType: DatabaseType$1): boolean;
+interface MigrationResult {
+  toBeCreated: Array<{
+    table: string;
+    fields: Record<string, any>;
+    order: number;
+  }>;
+  toBeAdded: Array<{
+    table: string;
+    fields: Record<string, any>;
+    order: number;
+  }>;
+  runMigrations: () => Promise<void>;
+  compileMigrations: () => Promise<string>;
+  migrations: any[];
+  needsMigration: boolean;
+}
+declare function getMigrations(db: Kysely<Database>, dbType: DatabaseType$1, options?: MigrationOptions): Promise<MigrationResult>;
+/**
+ * Run migrations if needed based on autoMigrate config
+ * @param db - Kysely database instance
+ * @param dbType - Database type
+ * @param autoMigrate - Auto-migrate configuration
+ * @param options - Migration options (schema, etc.)
+ * @returns true if migrations were run, false otherwise
+ */
+declare function runAutoMigrations(db: Kysely<Database>, dbType: DatabaseType$1, autoMigrate: boolean | 'development', options?: MigrationOptions): Promise<{
+  ran: boolean;
+  tables: string[];
+  fields: string[];
+}>;
+//#endregion
+//#region src/db/index.d.ts
+/**
+ * Supported database types
+ */
+type DatabaseType = 'postgres' | 'mysql' | 'sqlite' | 'mssql';
+/**
+ * Options for creating a database connection
+ */
+interface DatabaseOptions {
+  /**
+   * PostgreSQL schema name (sets search_path).
+   * Defaults to 'llmops'.
+   */
+  schema?: string;
+}
+/**
+ * Database connection options
+ */
+type DatabaseConnection = {
+  type: 'postgres';
+  dialect: PostgresDialect;
+} | {
+  type: 'mysql';
+  dialect: MysqlDialect;
+} | {
+  type: 'sqlite';
+  dialect: SqliteDialect;
+} | {
+  type: 'mssql';
+  dialect: MssqlDialect;
+} | {
+  type: DatabaseType;
+  kysely: Kysely<Database>;
+};
+/**
+ * Create a Kysely database instance with type safety
+ */
+declare function createDatabase(connection: DatabaseConnection): Kysely<Database>;
+/**
+ * Auto-detect database type from connection object
+ */
+declare function detectDatabaseType(db: unknown): DatabaseType | null;
+/**
+ * Create database from raw connection
+ *
+ * @param rawConnection - The raw database connection (pg Pool, sqlite Database, etc.)
+ * @param options - Optional configuration (schema for PostgreSQL)
+ */
+declare function createDatabaseFromConnection(rawConnection: any, options?: DatabaseOptions): Promise<Kysely<Database> | null>;
+//#endregion
+export { TargetingRulesTable as A, schemas as B, EnvironmentSecretsTable as C, Selectable as D, SCHEMA_METADATA as E, VariantsTable as F, variantVersionsSchema as H, configVariantsSchema as I, configsSchema as L, Variant as M, VariantVersion as N, TableName as O, VariantVersionsTable as P, environmentSecretsSchema as R, EnvironmentSecret as S, Insertable as T, variantsSchema as U, targetingRulesSchema as V, ConfigVariant as _, createDatabaseFromConnection as a, Database as b, MigrationResult as c, runAutoMigrations as d, parsePartialTableData as f, Config as g, validateTableData as h, createDatabase as i, Updateable as j, TargetingRule as k, getMigrations as l, validatePartialTableData as m, DatabaseOptions as n, detectDatabaseType as o, parseTableData as p, DatabaseType as r, MigrationOptions as s, DatabaseConnection as t, matchType as u, ConfigVariantsTable as v, EnvironmentsTable as w, Environment as x, ConfigsTable as y, environmentsSchema as z };