@llmops/core 0.1.0-beta.7 → 0.1.0

package/dist/index-BKx9C2tK.d.mts

@@ -0,0 +1,859 @@
+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';
+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): Promise<MigrationResult>;
+/**
+ * Run migrations if needed based on autoMigrate config
+ * @param db - Kysely database instance
+ * @param dbType - Database type
+ * @param autoMigrate - Auto-migrate configuration
+ * @returns true if migrations were run, false otherwise
+ */
+declare function runAutoMigrations(db: Kysely<Database>, dbType: DatabaseType$1, autoMigrate: boolean | 'development'): Promise<{
+  ran: boolean;
+  tables: string[];
+  fields: string[];
+}>;
+//#endregion
+//#region src/db/index.d.ts
+/**
+ * Supported database types
+ */
+type DatabaseType = 'postgres' | 'mysql' | 'sqlite' | 'mssql';
+/**
+ * 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
+ */
+declare function createDatabaseFromConnection(rawConnection: any): Promise<Kysely<Database> | null>;
+//#endregion
+export { Variant as A, variantVersionsSchema as B, Insertable as C, TargetingRule as D, TableName as E, configsSchema as F, environmentSecretsSchema as I, environmentsSchema as L, VariantVersionsTable as M, VariantsTable as N, TargetingRulesTable as O, configVariantsSchema as P, schemas as R, EnvironmentsTable as S, Selectable as T, variantsSchema as V, ConfigsTable as _, detectDatabaseType as a, EnvironmentSecret as b, matchType as c, parseTableData as d, validatePartialTableData as f, ConfigVariantsTable as g, ConfigVariant as h, createDatabaseFromConnection as i, VariantVersion as j, Updateable as k, runAutoMigrations as l, Config as m, DatabaseType as n, MigrationResult as o, validateTableData as p, createDatabase as r, getMigrations as s, DatabaseConnection as t, parsePartialTableData as u, Database as v, SCHEMA_METADATA as w, EnvironmentSecretsTable as x, Environment as y, targetingRulesSchema as z };