drizzle-kit 0.20.14-a183d8b → 0.20.14-b6f235e

package/cli/commands/migrate.d.ts

@@ -1,4 +1,5 @@
-import { CommonSchema, CommonSquashedSchema, Dialect } from "../../schemaValidator";
+import { Column, ColumnsResolverInput, ColumnsResolverOutput, Enum, ResolverInput, ResolverOutput, ResolverOutputWithMoved, Table } from "../../snapshotsDiffer";
+import { CommonSchema } from "../../schemaValidator";
 import { schema } from "../views";
 import { PgSchema } from "../../serializer/pgSchema";
 import { SQLiteSchema } from "../../serializer/sqliteSchema";
@@ -10,9 +11,77 @@ export type Named = {
 };
 export type NamedWithSchema = {
     name: string;
-    schema?: string;
+    schema: string;
 };
+export declare const schemasResolver: (input: ResolverInput<Table>) => Promise<ResolverOutput<Table>>;
+export declare const tablesResolver: (input: ResolverInput<Table>) => Promise<ResolverOutputWithMoved<Table>>;
+export declare const enumsResolver: (input: ResolverInput<Enum>) => Promise<ResolverOutputWithMoved<Enum>>;
+export declare const columnsResolver: (input: ColumnsResolverInput<Column>) => Promise<ColumnsResolverOutput<Column>>;
 export declare const prepareAndMigratePg: (config: GenerateConfig) => Promise<void>;
+export declare const preparePgPush: (config: {
+    schema: string | string[];
+}, snapshot: PgSchema, schemaFilter: string[]) => Promise<{
+    sqlStatements: string[];
+    statements: import("../../jsonStatements").JsonStatement[];
+    squashedPrev: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                isUnique?: any;
+                default?: any;
+                typeSchema?: string | undefined;
+                uniqueName?: string | undefined;
+                nullsNotDistinct?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, string>;
+            foreignKeys: Record<string, string>;
+            schema: string;
+            compositePrimaryKeys: Record<string, string>;
+            uniqueConstraints: Record<string, string>;
+        }>;
+        version: "6";
+        dialect: "pg";
+        schemas: Record<string, string>;
+        enums: Record<string, {
+            name: string;
+            values: string[];
+            schema: string;
+        }>;
+    };
+    squashedCur: {
+        tables: Record<string, {
+            name: string;
+            columns: Record<string, {
+                isUnique?: any;
+                default?: any;
+                typeSchema?: string | undefined;
+                uniqueName?: string | undefined;
+                nullsNotDistinct?: boolean | undefined;
+                name: string;
+                type: string;
+                primaryKey: boolean;
+                notNull: boolean;
+            }>;
+            indexes: Record<string, string>;
+            foreignKeys: Record<string, string>;
+            schema: string;
+            compositePrimaryKeys: Record<string, string>;
+            uniqueConstraints: Record<string, string>;
+        }>;
+        version: "6";
+        dialect: "pg";
+        schemas: Record<string, string>;
+        enums: Record<string, {
+            name: string;
+            values: string[];
+            schema: string;
+        }>;
+    };
+}>;
 export declare const prepareMySQLPush: (config: {
     schema: string | string[];
 }, snapshot: MySqlSchema) => Promise<{
@@ -26,12 +95,7 @@ export declare const prepareMySQLPush: (config: {
                 } | undefined>;
             } | undefined>;
         } | undefined;
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "mysql";
         tables: Record<string, {
-            schema?: string | undefined;
             name: string;
             columns: Record<string, {
                 default?: any;
@@ -68,11 +132,13 @@ export declare const prepareMySQLPush: (config: {
                 columns: string[];
             }>;
         }>;
-        schemas: Record<string, string>;
+        id: string;
+        prevId: string;
+        version: "6";
+        dialect: "mysql";
         _meta: {
             columns: Record<string, string>;
             tables: Record<string, string>;
-            schemas: Record<string, string>;
         };
     };
     validatedPrev: {
@@ -83,12 +149,7 @@ export declare const prepareMySQLPush: (config: {
                 } | undefined>;
             } | undefined>;
         } | undefined;
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "mysql";
         tables: Record<string, {
-            schema?: string | undefined;
             name: string;
             columns: Record<string, {
                 default?: any;
@@ -125,14 +186,18 @@ export declare const prepareMySQLPush: (config: {
                 columns: string[];
             }>;
         }>;
-        schemas: Record<string, string>;
+        id: string;
+        prevId: string;
+        version: "6";
+        dialect: "mysql";
         _meta: {
             columns: Record<string, string>;
             tables: Record<string, string>;
-            schemas: Record<string, string>;
         };
     };
 }>;
+export declare const prepareAndMigrateMysql: (config: GenerateConfig) => Promise<void>;
+export declare const prepareAndMigrateSqlite: (config: GenerateConfig) => Promise<void>;
 export declare const prepareSQLitePush: (config: {
     schema: string | string[];
 }, snapshot: SQLiteSchema) => Promise<{
@@ -140,8 +205,6 @@ export declare const prepareSQLitePush: (config: {
     statements: import("../../jsonStatements").JsonStatement[];
     squashedPrev: {
         enums?: any;
-        version: "5";
-        dialect: "sqlite";
         tables: Record<string, {
             name: string;
             columns: Record<string, {
@@ -157,11 +220,11 @@ export declare const prepareSQLitePush: (config: {
             compositePrimaryKeys: Record<string, string>;
             uniqueConstraints: Record<string, string>;
         }>;
+        version: "5";
+        dialect: "sqlite";
     };
     squashedCur: {
         enums?: any;
-        version: "5";
-        dialect: "sqlite";
         tables: Record<string, {
             name: string;
             columns: Record<string, {
@@ -177,6 +240,8 @@ export declare const prepareSQLitePush: (config: {
             compositePrimaryKeys: Record<string, string>;
             uniqueConstraints: Record<string, string>;
         }>;
+        version: "5";
+        dialect: "sqlite";
     };
     meta: {
         schemas: {};
@@ -184,85 +249,44 @@ export declare const prepareSQLitePush: (config: {
         columns: {};
     } | undefined;
 }>;
-export declare const preparePgPush: (config: {
-    schema: string | string[];
-}, snapshot: PgSchema, schemaFilter: string[]) => Promise<{
-    sqlStatements: string[];
-    statements: import("../../jsonStatements").JsonStatement[];
-    squashedPrev: {
-        version: "5";
-        dialect: "pg";
-        tables: Record<string, {
-            name: string;
-            columns: Record<string, {
-                isUnique?: any;
-                default?: any;
-                uniqueName?: string | undefined;
-                nullsNotDistinct?: boolean | undefined;
-                name: string;
-                type: string;
-                primaryKey: boolean;
-                notNull: boolean;
-            }>;
-            indexes: Record<string, string>;
-            foreignKeys: Record<string, string>;
-            schema: string;
-            compositePrimaryKeys: Record<string, string>;
-            uniqueConstraints: Record<string, string>;
-        }>;
-        schemas: Record<string, string>;
-        enums: Record<string, {
-            name: string;
-            values: Record<string, string>;
-        }>;
-    };
-    squashedCur: {
-        version: "5";
-        dialect: "pg";
-        tables: Record<string, {
-            name: string;
-            columns: Record<string, {
-                isUnique?: any;
-                default?: any;
-                uniqueName?: string | undefined;
-                nullsNotDistinct?: boolean | undefined;
-                name: string;
-                type: string;
-                primaryKey: boolean;
-                notNull: boolean;
-            }>;
-            indexes: Record<string, string>;
-            foreignKeys: Record<string, string>;
-            schema: string;
-            compositePrimaryKeys: Record<string, string>;
-            uniqueConstraints: Record<string, string>;
-        }>;
-        schemas: Record<string, string>;
-        enums: Record<string, {
-            name: string;
-            values: Record<string, string>;
-        }>;
-    };
+export declare const promptColumnsConflicts: <T extends Named>(tableName: string, newColumns: T[], missingColumns: T[]) => Promise<{
+    created: T[];
+    renamed: {
+        from: T;
+        to: T;
+    }[];
+    deleted: T[];
 }>;
-export declare const prepareAndMigrateMySql: (config: GenerateConfig) => Promise<void>;
-export declare const prepareAndMigrateSqlite: (config: GenerateConfig) => Promise<void>;
-export declare const prepareSQL: (prev: CommonSquashedSchema, cur: CommonSquashedSchema, dialect: Dialect, prevFull?: any, curFull?: any) => Promise<{
-    statements: import("../../jsonStatements").JsonStatement[];
-    sqlStatements: string[];
-    _meta: {
-        schemas: {};
-        tables: {};
-        columns: {};
-    } | undefined;
+export declare const promptNamedWithSchemasConflict: <T extends NamedWithSchema>(newItems: T[], missingItems: T[], entity: "table" | "enum") => Promise<{
+    created: T[];
+    renamed: {
+        from: T;
+        to: T;
+    }[];
+    moved: {
+        name: string;
+        schemaFrom: string;
+        schemaTo: string;
+    }[];
+    deleted: T[];
+}>;
+export declare const promptSchemasConflict: <T extends Named>(newSchemas: T[], missingSchemas: T[]) => Promise<{
+    created: T[];
+    renamed: {
+        from: T;
+        to: T;
+    }[];
+    deleted: T[];
 }>;
 export declare const BREAKPOINT = "--> statement-breakpoint\n";
-export declare const writeResult: ({ cur, sqlStatements, journal, _meta, outFolder, breakpoints, bundle, type, }: {
+export declare const writeResult: ({ cur, sqlStatements, journal, _meta, outFolder, breakpoints, name, bundle, type, }: {
     cur: CommonSchema;
     sqlStatements: string[];
     journal: Journal;
     _meta?: any;
     outFolder: string;
     breakpoints: boolean;
+    name?: string | undefined;
     bundle?: boolean | undefined;
     type?: "none" | "custom" | "introspect" | undefined;
 }) => void;

package/cli/commands/mysqlIntrospect.d.ts

@@ -6,12 +6,7 @@ export declare const connectToMySQL: (config: MySQLConnectionConfig) => Promise<
 }>;
 export declare const mysqlIntrospect: (config: MySQLConfigIntrospect, filters: string[]) => Promise<{
     schema: {
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "mysql";
         tables: Record<string, {
-            schema?: string | undefined;
             name: string;
             columns: Record<string, {
                 default?: any;
@@ -48,11 +43,13 @@ export declare const mysqlIntrospect: (config: MySQLConfigIntrospect, filters: s
                 columns: string[];
             }>;
         }>;
-        schemas: Record<string, string>;
+        id: string;
+        prevId: string;
+        version: "6";
+        dialect: "mysql";
         _meta: {
             columns: Record<string, string>;
             tables: Record<string, string>;
-            schemas: Record<string, string>;
         };
     };
     ts: {
@@ -67,12 +64,7 @@ export declare const mysqlPushIntrospect: (connection: {
     databaseName: string;
 }, filters: string[]) => Promise<{
     schema: {
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "mysql";
         tables: Record<string, {
-            schema?: string | undefined;
             name: string;
             columns: Record<string, {
                 default?: any;
@@ -109,11 +101,13 @@ export declare const mysqlPushIntrospect: (connection: {
                 columns: string[];
             }>;
         }>;
-        schemas: Record<string, string>;
+        id: string;
+        prevId: string;
+        version: "6";
+        dialect: "mysql";
         _meta: {
             columns: Record<string, string>;
             tables: Record<string, string>;
-            schemas: Record<string, string>;
         };
     };
 }>;

package/cli/commands/pgIntrospect.d.ts

@@ -5,15 +5,12 @@ export declare const pgPushIntrospect: (connection: {
     client: DrizzleDbClient;
 }, filters: string[], schemaFilters: string[]) => Promise<{
     schema: {
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "pg";
         tables: Record<string, {
             name: string;
             columns: Record<string, {
                 isUnique?: any;
                 default?: any;
+                typeSchema?: string | undefined;
                 uniqueName?: string | undefined;
                 nullsNotDistinct?: boolean | undefined;
                 name: string;
@@ -47,6 +44,10 @@ export declare const pgPushIntrospect: (connection: {
                 nullsNotDistinct: boolean;
             }>;
         }>;
+        id: string;
+        prevId: string;
+        version: "6";
+        dialect: "pg";
         schemas: Record<string, string>;
         _meta: {
             columns: Record<string, string>;
@@ -55,21 +56,19 @@ export declare const pgPushIntrospect: (connection: {
         };
         enums: Record<string, {
             name: string;
-            values: Record<string, string>;
+            values: string[];
+            schema: string;
         }>;
     };
 }>;
 export declare const pgIntrospect: (config: PgConfigIntrospect, filters: string[], schemaFilters: string[]) => Promise<{
     schema: {
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "pg";
         tables: Record<string, {
             name: string;
             columns: Record<string, {
                 isUnique?: any;
                 default?: any;
+                typeSchema?: string | undefined;
                 uniqueName?: string | undefined;
                 nullsNotDistinct?: boolean | undefined;
                 name: string;
@@ -103,6 +102,10 @@ export declare const pgIntrospect: (config: PgConfigIntrospect, filters: string[
                 nullsNotDistinct: boolean;
             }>;
         }>;
+        id: string;
+        prevId: string;
+        version: "6";
+        dialect: "pg";
         schemas: Record<string, string>;
         _meta: {
             columns: Record<string, string>;
@@ -111,7 +114,8 @@ export declare const pgIntrospect: (config: PgConfigIntrospect, filters: string[
         };
         enums: Record<string, {
             name: string;
-            values: Record<string, string>;
+            values: string[];
+            schema: string;
         }>;
     };
     ts: {
@@ -120,4 +124,7 @@ export declare const pgIntrospect: (config: PgConfigIntrospect, filters: string[
         decalrations: string;
         schemaEntry: string;
     };
+    relationsTs: {
+        file: string;
+    };
 }>;

package/cli/commands/sqliteIntrospect.d.ts

@@ -7,10 +7,6 @@ export declare const connectToSQLite: (config: SQLiteConnectionConfig) => Promis
 }>;
 export declare const sqliteIntrospect: (config: SQLiteCliConfig, filters: string[]) => Promise<{
     schema: {
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "sqlite";
         tables: Record<string, {
             name: string;
             columns: Record<string, {
@@ -45,6 +41,10 @@ export declare const sqliteIntrospect: (config: SQLiteCliConfig, filters: string
                 columns: string[];
             }>;
         }>;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "sqlite";
         _meta: {
             columns: Record<string, string>;
             tables: Record<string, string>;
@@ -60,10 +60,6 @@ export declare const sqliteIntrospect: (config: SQLiteCliConfig, filters: string
 }>;
 export declare const sqlitePushIntrospect: (client: DrizzleDbClient, filters: string[]) => Promise<{
     schema: {
-        id: string;
-        prevId: string;
-        version: "5";
-        dialect: "sqlite";
         tables: Record<string, {
             name: string;
             columns: Record<string, {
@@ -98,6 +94,10 @@ export declare const sqlitePushIntrospect: (client: DrizzleDbClient, filters: st
                 columns: string[];
             }>;
         }>;
+        id: string;
+        prevId: string;
+        version: "5";
+        dialect: "sqlite";
         _meta: {
             columns: Record<string, string>;
             tables: Record<string, string>;

package/cli/commands/utils.d.ts

@@ -1,9 +1,9 @@
-import { CliConfigGenerate, CliParamsPush } from "..";
 import { MySQLPushConfig } from "../validations/mysql";
 import { PgPushConfig } from "../validations/pg";
 import { SQLitePushConfig } from "../validations/sqlite";
 import { CliConfig } from "../validations/common";
 import { Dialect } from "src/schemaValidator";
+import { CliCheckConfig, CliConfigGenerate, CliParamsPush } from "../validations/cli";
 export declare const safeRegister: () => Promise<{
     unregister: () => void;
 }>;
@@ -12,6 +12,7 @@ export type GenerateConfig = {
     schema: string | string[];
     out: string;
     breakpoints: boolean;
+    name?: string;
     custom: boolean;
     bundle: boolean;
 };
@@ -21,10 +22,9 @@ export declare const preparePushConfig: (options: CliParamsPush) => Promise<{
     schemaFiles: string[];
     tablesFilter: string[];
 }>;
-export declare const assertOutFolder: (it: {
-    config?: string;
-} | {
+export declare const assertOutFolder: (it: CliCheckConfig) => Promise<{
     out: string;
-}) => Promise<string>;
+    dialect: Dialect;
+}>;
 export declare const drizzleConfigFromFile: (configPath?: string) => Promise<CliConfig>;
 export declare const readDrizzleConfig: (configPath?: string) => Promise<any>;

package/cli/{index.d.ts → validations/cli.d.ts}

@@ -1,14 +1,14 @@
 import { TypeOf } from "zod";
-import "../@types/utils";
-import "dotenv/config";
-declare const cliConfigGenerate: import("zod").ZodObject<{
+export declare const cliConfigGenerate: import("zod").ZodObject<{
     dialect: import("zod").ZodOptional<import("zod").ZodEnum<["pg", "mysql", "sqlite"]>>;
     schema: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
     out: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
     config: import("zod").ZodOptional<import("zod").ZodString>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
     breakpoints: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
     custom: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
 }, "strict", import("zod").ZodTypeAny, {
+    name?: string | undefined;
     schema?: string | string[] | undefined;
     dialect?: "mysql" | "pg" | "sqlite" | undefined;
     config?: string | undefined;
@@ -16,28 +16,29 @@ declare const cliConfigGenerate: import("zod").ZodObject<{
     out: string;
     breakpoints: boolean;
 }, {
+    name?: string | undefined;
     custom?: boolean | undefined;
     schema?: string | string[] | undefined;
     dialect?: "mysql" | "pg" | "sqlite" | undefined;
-    out?: string | undefined;
     config?: string | undefined;
+    out?: string | undefined;
     breakpoints?: boolean | undefined;
 }>;
 export type CliConfigGenerate = TypeOf<typeof cliConfigGenerate>;
-declare const cliParamsPush: import("zod").ZodObject<{
+export declare const cliParamsPush: import("zod").ZodObject<{
     config: import("zod").ZodOptional<import("zod").ZodString>;
     dialect: import("zod").ZodOptional<import("zod").ZodEnum<["pg", "mysql", "sqlite"]>>;
     schema: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
     tablesFilter: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
     driver: import("zod").ZodOptional<import("zod").ZodString>;
     connectionString: import("zod").ZodOptional<import("zod").ZodString>;
+    uri: import("zod").ZodOptional<import("zod").ZodString>;
     host: import("zod").ZodOptional<import("zod").ZodString>;
     port: import("zod").ZodOptional<import("zod").ZodString>;
     user: import("zod").ZodOptional<import("zod").ZodString>;
     password: import("zod").ZodOptional<import("zod").ZodString>;
     database: import("zod").ZodOptional<import("zod").ZodString>;
     ssl: import("zod").ZodOptional<import("zod").ZodString>;
-    uri: import("zod").ZodOptional<import("zod").ZodString>;
     authToken: import("zod").ZodOptional<import("zod").ZodString>;
     verbose: import("zod").ZodOptional<import("zod").ZodBoolean>;
     strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
@@ -55,9 +56,9 @@ declare const cliParamsPush: import("zod").ZodObject<{
     password?: string | undefined;
     database?: string | undefined;
     connectionString?: string | undefined;
-    authToken?: string | undefined;
-    ssl?: string | undefined;
     uri?: string | undefined;
+    ssl?: string | undefined;
+    authToken?: string | undefined;
 }, {
     strict?: boolean | undefined;
     schema?: string | string[] | undefined;
@@ -72,23 +73,35 @@ declare const cliParamsPush: import("zod").ZodObject<{
     password?: string | undefined;
     database?: string | undefined;
     connectionString?: string | undefined;
-    authToken?: string | undefined;
-    ssl?: string | undefined;
     uri?: string | undefined;
+    ssl?: string | undefined;
+    authToken?: string | undefined;
 }>;
 export type CliParamsPush = TypeOf<typeof cliParamsPush>;
-export declare const checkSchema: import("zod").ZodObject<{
+export declare const configCheck: import("zod").ZodObject<{
+    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["pg", "mysql", "sqlite"]>>;
     out: import("zod").ZodOptional<import("zod").ZodString>;
-    config: import("zod").ZodOptional<import("zod").ZodString>;
-    driver: import("zod").ZodOptional<import("zod").ZodString>;
-}, "strict", import("zod").ZodTypeAny, {
+}, "strip", import("zod").ZodTypeAny, {
+    dialect?: "mysql" | "pg" | "sqlite" | undefined;
     out?: string | undefined;
-    config?: string | undefined;
-    driver?: string | undefined;
 }, {
+    dialect?: "mysql" | "pg" | "sqlite" | undefined;
     out?: string | undefined;
-    config?: string | undefined;
-    driver?: string | undefined;
 }>;
-export type CheckConfig = TypeOf<typeof checkSchema>;
-export {};
+export declare const cliConfigCheck: import("zod").ZodIntersection<import("zod").ZodObject<{
+    config: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    config?: string | undefined;
+}, {
+    config?: string | undefined;
+}>, import("zod").ZodObject<{
+    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["pg", "mysql", "sqlite"]>>;
+    out: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    dialect?: "mysql" | "pg" | "sqlite" | undefined;
+    out?: string | undefined;
+}, {
+    dialect?: "mysql" | "pg" | "sqlite" | undefined;
+    out?: string | undefined;
+}>>;
+export type CliCheckConfig = TypeOf<typeof cliConfigCheck>;

package/cli/validations/common.d.ts

@@ -1,5 +1,5 @@
 import { TypeOf } from "zod";
-export type Commands = "introspect:sqlite" | "introspect:pg" | "generate" | "check:pg" | "check:mysql" | "check:sqlite" | "up:pg" | "up:mysql" | "up:sqlite" | "drop" | "introspect:mysql" | "push";
+export type Commands = "introspect:sqlite" | "introspect:pg" | "generate" | "check" | "up" | "drop" | "introspect:mysql" | "push";
 /**
  * This function checks an input from a user and if there are any params together with config path - return true
  * @param options - user input

package/cli/views.d.ts

@@ -1,6 +1,6 @@
 import { Prompt, TaskView } from "hanji";
 import type { CommonSchema } from "../schemaValidator";
-import type { Named } from "./commands/migrate";
+import type { Named, NamedWithSchema } from "./commands/migrate";
 export declare const warning: (msg: string) => void;
 export declare const err: (msg: string) => void;
 export declare const info: (msg: string, greyMsg?: string) => string;
@@ -10,7 +10,7 @@ export interface RenamePropmtItem<T> {
     from: T;
     to: T;
 }
-export declare const isRenamePromptItem: <T extends Named>(item: T | RenamePropmtItem<T>) => item is RenamePropmtItem<T>;
+export declare const isRenamePromptItem: <T extends Named>(item: RenamePropmtItem<T> | T) => item is RenamePropmtItem<T>;
 export declare class ResolveColumnSelect<T extends Named> extends Prompt<RenamePropmtItem<T> | T> {
     private readonly tableName;
     private readonly base;
@@ -19,10 +19,12 @@ export declare class ResolveColumnSelect<T extends Named> extends Prompt<RenameP
     render(status: "idle" | "submitted" | "aborted"): string;
     result(): RenamePropmtItem<T> | T;
 }
-export declare class ResolveTableSelect<T extends Named> extends Prompt<RenamePropmtItem<T> | T> {
+export declare const tableKey: (it: NamedWithSchema) => string;
+export declare class ResolveSelect<T extends NamedWithSchema> extends Prompt<RenamePropmtItem<T> | T> {
     private readonly base;
+    private readonly entityType;
     private readonly state;
-    constructor(base: Named, data: (RenamePropmtItem<T> | T)[]);
+    constructor(base: T, data: (RenamePropmtItem<T> | T)[], entityType: "table" | "enum");
     render(status: "idle" | "submitted" | "aborted"): string;
     result(): RenamePropmtItem<T> | T;
 }

package/global.d.ts

@@ -1,4 +1,6 @@
 export declare const originUUID = "00000000-0000-0000-0000-000000000000";
-export declare const snapshotVersion = "5";
+export declare const snapshotVersion = "6";
 export declare function assertUnreachable(x: never): never;
 export declare const mapValues: <IN, OUT>(obj: Record<string, IN>, map: (input: IN) => OUT) => Record<string, OUT>;
+export declare const mapKeys: <T>(obj: Record<string, T>, map: (key: string, value: T) => string) => Record<string, T>;
+export declare const mapEntries: <T>(obj: Record<string, T>, map: (key: string, value: T) => [string, T]) => Record<string, T>;

package/index.js

@@ -1,3 +1,4 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;