drizzle-kit 0.20.17-5938f5d → 0.20.17-7446198

package/cli/commands/migrate.d.ts

@@ -41,7 +41,7 @@ export declare const preparePgPush: (schemaPath: string | string[], snapshot: Pg
             uniqueConstraints: Record<string, string>;
         }>;
         version: "6";
-        dialect: "pg";
+        dialect: "postgresql";
         schemas: Record<string, string>;
         enums: Record<string, {
             name: string;
@@ -70,7 +70,7 @@ export declare const preparePgPush: (schemaPath: string | string[], snapshot: Pg
             uniqueConstraints: Record<string, string>;
         }>;
         version: "6";
-        dialect: "pg";
+        dialect: "postgresql";
         schemas: Record<string, string>;
         enums: Record<string, {
             name: string;
@@ -122,7 +122,7 @@ export declare const prepareMySQLPush: (schemaPath: string | string[], snapshot:
         }>;
         id: string;
         prevId: string;
-        version: "6";
+        version: "5";
         dialect: "mysql";
         _meta: {
             columns: Record<string, string>;
@@ -176,7 +176,7 @@ export declare const prepareMySQLPush: (schemaPath: string | string[], snapshot:
         }>;
         id: string;
         prevId: string;
-        version: "6";
+        version: "5";
         dialect: "mysql";
         _meta: {
             columns: Record<string, string>;

package/cli/commands/mysqlIntrospect.d.ts

@@ -1,9 +1,4 @@
-import type { MysqlCredentials } from "../validations/mysql";
 import type { DB } from "../../utils";
-export declare const connectToMySQL: (credentials: MysqlCredentials) => Promise<{
-    db: DB;
-    database: string;
-}>;
 export declare const mysqlPushIntrospect: (db: DB, databaseName: string, filters: string[]) => Promise<{
     schema: {
         tables: Record<string, {
@@ -45,7 +40,7 @@ export declare const mysqlPushIntrospect: (db: DB, databaseName: string, filters
         }>;
         id: string;
         prevId: string;
-        version: "6";
+        version: "5";
         dialect: "mysql";
         _meta: {
             columns: Record<string, string>;

package/cli/commands/pgIntrospect.d.ts

@@ -43,7 +43,7 @@ export declare const pgPushIntrospect: (db: DB, filters: string[], schemaFilters
         id: string;
         prevId: string;
         version: "6";
-        dialect: "pg";
+        dialect: "postgresql";
         schemas: Record<string, string>;
         _meta: {
             columns: Record<string, string>;

package/cli/commands/sqliteIntrospect.d.ts

@@ -1,7 +1,6 @@
 import type { SqliteCredentials } from "../validations/sqlite";
 import type { SQLiteDB } from "../../utils";
 import { Casing } from "../validations/common";
-export declare const connectToSQLite: (credentials: SqliteCredentials) => Promise<SQLiteDB>;
 export declare const sqliteIntrospect: (credentials: SqliteCredentials, filters: string[], casing: Casing) => Promise<{
     schema: {
         tables: Record<string, {

package/cli/commands/sqlitePushUtils.d.ts

@@ -1,10 +1,10 @@
 import { SQLiteSchemaInternal, SQLiteSchemaSquashed } from "../../serializer/sqliteSchema";
 import type { JsonStatement } from "../../jsonStatements";
-import type { DB } from "../../utils";
+import type { SQLiteDB } from "../../utils";
 export declare const _moveDataStatements: (tableName: string, json: SQLiteSchemaSquashed, dataLoss?: boolean) => string[];
 export declare const getOldTableName: (tableName: string, meta: SQLiteSchemaInternal["_meta"]) => string;
 export declare const getNewTableName: (tableName: string, meta: SQLiteSchemaInternal["_meta"]) => string;
-export declare const logSuggestionsAndReturn: (connection: DB, statements: JsonStatement[], json1: SQLiteSchemaSquashed, json2: SQLiteSchemaSquashed, meta: SQLiteSchemaInternal["_meta"]) => Promise<{
+export declare const logSuggestionsAndReturn: (connection: SQLiteDB, statements: JsonStatement[], json1: SQLiteSchemaSquashed, json2: SQLiteSchemaSquashed, meta: SQLiteSchemaInternal["_meta"]) => Promise<{
     statementsToExecute: string[];
     shouldAskForApprove: boolean;
     infoToPrint: string[];

package/cli/commands/utils.d.ts

@@ -2,7 +2,7 @@ import { MysqlCredentials } from "../validations/mysql";
 import { PostgresCredentials } from "../validations/pg";
 import { SqliteCredentials } from "../validations/sqlite";
 import { Casing, CliConfig } from "../validations/common";
-import type { Dialect } from "../../schemaValidator";
+import { type Dialect } from "../../schemaValidator";
 import { CliCheckConfig, CliConfigGenerate } from "../validations/cli";
 export declare const safeRegister: () => Promise<{
     unregister: () => void;
@@ -22,7 +22,7 @@ export declare const preparePushConfig: (options: Record<string, unknown>) => Pr
     dialect: "mysql";
     credentials: MysqlCredentials;
 } | {
-    dialect: "pg";
+    dialect: "postgresql";
     credentials: PostgresCredentials;
 } | {
     dialect: "sqlite";
@@ -38,7 +38,7 @@ export declare const preparePullConfig: (options: Record<string, unknown>) => Pr
     dialect: "mysql";
     credentials: MysqlCredentials;
 } | {
-    dialect: "pg";
+    dialect: "postgresql";
     credentials: PostgresCredentials;
 } | {
     dialect: "sqlite";
@@ -50,6 +50,128 @@ export declare const preparePullConfig: (options: Record<string, unknown>) => Pr
     tablesFilter: string[];
     schemasFilter: string[];
 }>;
+export declare const prepareStudioConfig: (options: Record<string, unknown>) => Promise<{
+    dialect: "postgresql";
+    schema: string | string[];
+    host: string;
+    port: number;
+    credentials: {
+        host: string;
+        user: string;
+        database: string;
+        port?: number | undefined;
+        password?: string | undefined;
+        ssl?: boolean | undefined;
+    } | {
+        url: string;
+    } | {
+        database: string;
+        driver: "aws-data-api";
+        secretArn: string;
+        resourceArn: string;
+    };
+} | {
+    dialect: "mysql";
+    schema: string | string[];
+    host: string;
+    port: number;
+    credentials: {
+        host: string;
+        user: string;
+        database: string;
+        port?: number | undefined;
+        password?: string | undefined;
+    } | {
+        url: string;
+    };
+} | {
+    dialect: "sqlite";
+    schema: string | string[];
+    host: string;
+    port: number;
+    credentials: {
+        url: string;
+        driver: "turso";
+        authToken: string;
+    } | {
+        url: string;
+    };
+}>;
+export declare const migrateConfig: import("zod").ZodObject<{
+    dialect: import("zod").ZodEnum<["postgresql", "mysql", "sqlite"]>;
+    out: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    migrations: import("zod").ZodOptional<import("zod").ZodObject<{
+        table: import("zod").ZodOptional<import("zod").ZodString>;
+        schema: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strip", import("zod").ZodTypeAny, {
+        schema?: string | undefined;
+        table?: string | undefined;
+    }, {
+        schema?: string | undefined;
+        table?: string | undefined;
+    }>>;
+}, "strip", import("zod").ZodTypeAny, {
+    dialect: "postgresql" | "mysql" | "sqlite";
+    out: string;
+    migrations?: {
+        schema?: string | undefined;
+        table?: string | undefined;
+    } | undefined;
+}, {
+    dialect: "postgresql" | "mysql" | "sqlite";
+    out?: string | undefined;
+    migrations?: {
+        schema?: string | undefined;
+        table?: string | undefined;
+    } | undefined;
+}>;
+export declare const prepareMigrateConfig: (options: Record<string, unknown>) => Promise<{
+    dialect: "postgresql";
+    out: string;
+    credentials: {
+        host: string;
+        user: string;
+        database: string;
+        port?: number | undefined;
+        password?: string | undefined;
+        ssl?: boolean | undefined;
+    } | {
+        url: string;
+    } | {
+        database: string;
+        driver: "aws-data-api";
+        secretArn: string;
+        resourceArn: string;
+    };
+    schema: string | undefined;
+    table: string | undefined;
+} | {
+    dialect: "mysql";
+    out: string;
+    credentials: {
+        host: string;
+        user: string;
+        database: string;
+        port?: number | undefined;
+        password?: string | undefined;
+    } | {
+        url: string;
+    };
+    schema: string | undefined;
+    table: string | undefined;
+} | {
+    dialect: "sqlite";
+    out: string;
+    credentials: {
+        url: string;
+        driver: "turso";
+        authToken: string;
+    } | {
+        url: string;
+    };
+    schema: string | undefined;
+    table: string | undefined;
+}>;
 export declare const assertOutFolder: (it: CliCheckConfig) => Promise<{
     out: string;
     dialect: Dialect;

package/cli/connections.d.ts

@@ -0,0 +1,18 @@
+import type { DB, Proxy, SQLiteDB, SqliteProxy } from "../utils";
+import type { PostgresCredentials } from "./validations/pg";
+import type { MysqlCredentials } from "./validations/mysql";
+import type { SqliteCredentials } from "./validations/sqlite";
+import type { MigrationConfig } from "drizzle-orm/migrator";
+export declare const preparePostgresDB: (credentials: PostgresCredentials) => Promise<DB & {
+    proxy: Proxy;
+    migrate: (config: string | MigrationConfig) => Promise<void>;
+}>;
+export declare const connectToMySQL: (it: MysqlCredentials) => Promise<{
+    db: DB;
+    proxy: Proxy;
+    database: string;
+    migrate: (config: MigrationConfig) => Promise<void>;
+}>;
+export declare const connectToSQLite: (credentials: SqliteCredentials) => Promise<SQLiteDB & SqliteProxy & {
+    migrate: (config: MigrationConfig) => Promise<void>;
+}>;

package/cli/validations/cli.d.ts

@@ -1,6 +1,6 @@
 import { TypeOf } from "zod";
 export declare const cliConfigGenerate: import("zod").ZodObject<{
-    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["pg", "mysql", "sqlite"]>>;
+    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["postgresql", "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>;
@@ -13,24 +13,24 @@ export declare const cliConfigGenerate: import("zod").ZodObject<{
     breakpoints: boolean;
     name?: string | undefined;
     schema?: string | string[] | undefined;
-    dialect?: "mysql" | "pg" | "sqlite" | undefined;
+    dialect?: "postgresql" | "mysql" | "sqlite" | undefined;
     config?: string | undefined;
 }, {
     name?: string | undefined;
     custom?: boolean | undefined;
     schema?: string | string[] | undefined;
-    dialect?: "mysql" | "pg" | "sqlite" | undefined;
+    dialect?: "postgresql" | "mysql" | "sqlite" | undefined;
     config?: string | undefined;
     out?: string | undefined;
     breakpoints?: boolean | undefined;
 }>;
 export type CliConfigGenerate = TypeOf<typeof cliConfigGenerate>;
 export declare const pushParams: import("zod").ZodObject<{
-    dialect: import("zod").ZodEnum<["pg", "mysql", "sqlite"]>;
+    dialect: import("zod").ZodEnum<["postgresql", "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">]>>;
-    schemaFilters: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>>;
-    driver: import("zod").ZodString;
+    schemaFilter: import("zod").ZodDefault<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>;
     url: import("zod").ZodOptional<import("zod").ZodString>;
@@ -44,46 +44,46 @@ export declare const pushParams: import("zod").ZodObject<{
     verbose: import("zod").ZodOptional<import("zod").ZodBoolean>;
     strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
 }, "strip", import("zod").ZodTypeAny, {
-    dialect: "mysql" | "pg" | "sqlite";
-    driver: string;
-    schemaFilters: string | string[];
+    dialect: "postgresql" | "mysql" | "sqlite";
+    schemaFilter: string | string[];
     strict?: boolean | undefined;
     schema?: string | string[] | undefined;
     url?: string | undefined;
-    tablesFilter?: string | string[] | undefined;
-    verbose?: boolean | undefined;
     host?: string | undefined;
     port?: string | undefined;
     user?: string | undefined;
     password?: string | undefined;
     database?: string | undefined;
-    connectionString?: string | undefined;
     uri?: string | undefined;
+    driver?: string | undefined;
+    connectionString?: string | undefined;
     ssl?: string | undefined;
     authToken?: string | undefined;
+    tablesFilter?: string | string[] | undefined;
+    verbose?: boolean | undefined;
 }, {
-    dialect: "mysql" | "pg" | "sqlite";
-    driver: string;
+    dialect: "postgresql" | "mysql" | "sqlite";
     strict?: boolean | undefined;
     schema?: string | string[] | undefined;
     url?: string | undefined;
-    tablesFilter?: string | string[] | undefined;
-    verbose?: boolean | undefined;
     host?: string | undefined;
     port?: string | undefined;
     user?: string | undefined;
     password?: string | undefined;
     database?: string | undefined;
-    connectionString?: string | undefined;
-    schemaFilters?: string | string[] | undefined;
     uri?: string | undefined;
+    driver?: string | undefined;
+    connectionString?: string | undefined;
     ssl?: string | undefined;
     authToken?: string | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: string | string[] | undefined;
+    verbose?: boolean | undefined;
 }>;
 export type PushParams = TypeOf<typeof pushParams>;
 export declare const pullParams: import("zod").ZodObject<{
     config: import("zod").ZodOptional<import("zod").ZodString>;
-    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["pg", "mysql", "sqlite"]>>;
+    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["postgresql", "mysql", "sqlite"]>>;
     out: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
     tablesFilter: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
     schemaFilter: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>>;
@@ -98,56 +98,56 @@ export declare const pullParams: import("zod").ZodObject<{
     ssl: import("zod").ZodOptional<import("zod").ZodString>;
     url: import("zod").ZodOptional<import("zod").ZodString>;
     authToken: import("zod").ZodOptional<import("zod").ZodString>;
-    "introspect-casing": import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodLiteral<"camel">, import("zod").ZodLiteral<"preserve">]>>;
+    introspectCasing: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodLiteral<"camel">, import("zod").ZodLiteral<"preserve">]>>;
     breakpoints: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
-}, "strip", import("zod").ZodTypeAny, {
-    out: string;
-    breakpoints: boolean;
-    schemaFilter: string | string[];
-    "introspect-casing": "camel" | "preserve";
-    dialect?: "mysql" | "pg" | "sqlite" | undefined;
-    url?: string | undefined;
-    config?: string | undefined;
-    driver?: string | undefined;
-    tablesFilter?: string | string[] | undefined;
-    host?: string | undefined;
-    port?: string | undefined;
-    user?: string | undefined;
-    password?: string | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    uri?: string | undefined;
-    ssl?: string | undefined;
-    authToken?: string | undefined;
-}, {
-    dialect?: "mysql" | "pg" | "sqlite" | undefined;
-    url?: string | undefined;
-    config?: string | undefined;
-    out?: string | undefined;
-    breakpoints?: boolean | undefined;
-    driver?: string | undefined;
-    tablesFilter?: string | string[] | undefined;
-    schemaFilter?: string | string[] | undefined;
-    host?: string | undefined;
-    port?: string | undefined;
-    user?: string | undefined;
-    password?: string | undefined;
-    database?: string | undefined;
-    connectionString?: string | undefined;
-    uri?: string | undefined;
-    ssl?: string | undefined;
-    authToken?: string | undefined;
-    "introspect-casing"?: "camel" | "preserve" | undefined;
-}>;
+}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+    config: import("zod").ZodOptional<import("zod").ZodString>;
+    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["postgresql", "mysql", "sqlite"]>>;
+    out: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    tablesFilter: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
+    schemaFilter: import("zod").ZodDefault<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>;
+    url: import("zod").ZodOptional<import("zod").ZodString>;
+    authToken: import("zod").ZodOptional<import("zod").ZodString>;
+    introspectCasing: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodLiteral<"camel">, import("zod").ZodLiteral<"preserve">]>>;
+    breakpoints: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+    config: import("zod").ZodOptional<import("zod").ZodString>;
+    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["postgresql", "mysql", "sqlite"]>>;
+    out: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    tablesFilter: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
+    schemaFilter: import("zod").ZodDefault<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>;
+    url: import("zod").ZodOptional<import("zod").ZodString>;
+    authToken: import("zod").ZodOptional<import("zod").ZodString>;
+    introspectCasing: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodLiteral<"camel">, import("zod").ZodLiteral<"preserve">]>>;
+    breakpoints: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+}, import("zod").ZodTypeAny, "passthrough">>;
 export type PullParams = TypeOf<typeof pullParams>;
 export declare const configCheck: import("zod").ZodObject<{
-    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["pg", "mysql", "sqlite"]>>;
+    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["postgresql", "mysql", "sqlite"]>>;
     out: import("zod").ZodOptional<import("zod").ZodString>;
 }, "strip", import("zod").ZodTypeAny, {
-    dialect?: "mysql" | "pg" | "sqlite" | undefined;
+    dialect?: "postgresql" | "mysql" | "sqlite" | undefined;
     out?: string | undefined;
 }, {
-    dialect?: "mysql" | "pg" | "sqlite" | undefined;
+    dialect?: "postgresql" | "mysql" | "sqlite" | undefined;
     out?: string | undefined;
 }>;
 export declare const cliConfigCheck: import("zod").ZodIntersection<import("zod").ZodObject<{
@@ -157,13 +157,13 @@ export declare const cliConfigCheck: import("zod").ZodIntersection<import("zod")
 }, {
     config?: string | undefined;
 }>, import("zod").ZodObject<{
-    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["pg", "mysql", "sqlite"]>>;
+    dialect: import("zod").ZodOptional<import("zod").ZodEnum<["postgresql", "mysql", "sqlite"]>>;
     out: import("zod").ZodOptional<import("zod").ZodString>;
 }, "strip", import("zod").ZodTypeAny, {
-    dialect?: "mysql" | "pg" | "sqlite" | undefined;
+    dialect?: "postgresql" | "mysql" | "sqlite" | undefined;
     out?: string | undefined;
 }, {
-    dialect?: "mysql" | "pg" | "sqlite" | undefined;
+    dialect?: "postgresql" | "mysql" | "sqlite" | undefined;
     out?: string | undefined;
 }>>;
 export type CliCheckConfig = TypeOf<typeof cliConfigCheck>;

package/cli/validations/common.d.ts

@@ -12,7 +12,7 @@ export declare const postgresDriver: import("zod").ZodLiteral<"pg">;
 export declare const mysqlDriver: import("zod").ZodLiteral<"mysql2">;
 export declare const driver: import("zod").ZodUnion<[import("zod").ZodUnion<[import("zod").ZodLiteral<"better-sqlite">, import("zod").ZodLiteral<"turso">, import("zod").ZodLiteral<"libsql">, import("zod").ZodLiteral<"d1">, import("zod").ZodLiteral<"expo">]>, import("zod").ZodLiteral<"pg">, import("zod").ZodLiteral<"mysql2">]>;
 export declare const configCommonSchema: import("zod").ZodObject<{
-    dialect: import("zod").ZodEnum<["pg", "mysql", "sqlite"]>;
+    dialect: import("zod").ZodEnum<["postgresql", "mysql", "sqlite"]>;
     schema: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>;
     out: import("zod").ZodOptional<import("zod").ZodString>;
     breakpoints: import("zod").ZodDefault<import("zod").ZodBoolean>;
@@ -21,18 +21,18 @@ export declare const configCommonSchema: import("zod").ZodObject<{
     schemaFilter: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
 }, "strip", import("zod").ZodTypeAny, {
     schema: string | string[];
-    dialect: "mysql" | "pg" | "sqlite";
+    dialect: "postgresql" | "mysql" | "sqlite";
     breakpoints: boolean;
     schemaFilter: string | string[];
+    driver?: "turso" | "expo" | "pg" | "mysql2" | "libsql" | "better-sqlite" | "d1" | undefined;
     out?: string | undefined;
-    driver?: "pg" | "turso" | "better-sqlite" | "libsql" | "d1" | "mysql2" | "expo" | undefined;
     tablesFilter?: string | string[] | undefined;
 }, {
     schema: string | string[];
-    dialect: "mysql" | "pg" | "sqlite";
+    dialect: "postgresql" | "mysql" | "sqlite";
+    driver?: "turso" | "expo" | "pg" | "mysql2" | "libsql" | "better-sqlite" | "d1" | undefined;
     out?: string | undefined;
     breakpoints?: boolean | undefined;
-    driver?: "pg" | "turso" | "better-sqlite" | "libsql" | "d1" | "mysql2" | "expo" | undefined;
     tablesFilter?: string | string[] | undefined;
     schemaFilter?: string | string[] | undefined;
 }>;
@@ -108,7 +108,7 @@ export declare const configGenerateSchema: import("zod").ZodObject<{
 }>;
 export type GenerateSchema = TypeOf<typeof configGenerateSchema>;
 export declare const configPushSchema: import("zod").ZodObject<{
-    dialect: import("zod").ZodEnum<["pg", "mysql", "sqlite"]>;
+    dialect: import("zod").ZodEnum<["postgresql", "mysql", "sqlite"]>;
     schema: 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">]>>;
     schemaFilter: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
@@ -118,14 +118,14 @@ export declare const configPushSchema: import("zod").ZodObject<{
 }, "strip", import("zod").ZodTypeAny, {
     strict: boolean;
     schema: string | string[];
-    dialect: "mysql" | "pg" | "sqlite";
+    dialect: "postgresql" | "mysql" | "sqlite";
     schemaFilter: string | string[];
     verbose: boolean;
     out?: string | undefined;
     tablesFilter?: string | string[] | undefined;
 }, {
     schema: string | string[];
-    dialect: "mysql" | "pg" | "sqlite";
+    dialect: "postgresql" | "mysql" | "sqlite";
     strict?: boolean | undefined;
     out?: string | undefined;
     tablesFilter?: string | string[] | undefined;
@@ -158,7 +158,7 @@ export declare const mysqlConnectionSchema: import("zod").ZodUnion<[import("zod"
     connectionString: string;
 }>, import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>]>;
 export declare const mySqlCliConfigSchema: import("zod").ZodIntersection<import("zod").ZodObject<{
-    dialect: import("zod").ZodEnum<["pg", "mysql", "sqlite"]>;
+    dialect: import("zod").ZodEnum<["postgresql", "mysql", "sqlite"]>;
     schema: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>;
     out: import("zod").ZodOptional<import("zod").ZodString>;
     breakpoints: import("zod").ZodDefault<import("zod").ZodBoolean>;
@@ -167,18 +167,18 @@ export declare const mySqlCliConfigSchema: import("zod").ZodIntersection<import(
     schemaFilter: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>>;
 }, "strip", import("zod").ZodTypeAny, {
     schema: string | string[];
-    dialect: "mysql" | "pg" | "sqlite";
+    dialect: "postgresql" | "mysql" | "sqlite";
     breakpoints: boolean;
     schemaFilter: string | string[];
+    driver?: "turso" | "expo" | "pg" | "mysql2" | "libsql" | "better-sqlite" | "d1" | undefined;
     out?: string | undefined;
-    driver?: "pg" | "turso" | "better-sqlite" | "libsql" | "d1" | "mysql2" | "expo" | undefined;
     tablesFilter?: string | string[] | undefined;
 }, {
     schema: string | string[];
-    dialect: "mysql" | "pg" | "sqlite";
+    dialect: "postgresql" | "mysql" | "sqlite";
+    driver?: "turso" | "expo" | "pg" | "mysql2" | "libsql" | "better-sqlite" | "d1" | undefined;
     out?: string | undefined;
     breakpoints?: boolean | undefined;
-    driver?: "pg" | "turso" | "better-sqlite" | "libsql" | "d1" | "mysql2" | "expo" | undefined;
     tablesFilter?: string | string[] | undefined;
     schemaFilter?: string | string[] | undefined;
 }>, import("zod").ZodUnion<[import("zod").ZodObject<{

package/cli/validations/mysql.d.ts

@@ -18,17 +18,11 @@ export declare const mysqlCredentials: import("zod").ZodUnion<[import("zod").Zod
     user?: string | undefined;
     password?: string | undefined;
 }>, import("zod").ZodObject<{
-    uri: import("zod").ZodString;
+    url: import("zod").ZodString;
 }, "strip", import("zod").ZodTypeAny, {
-    uri: string;
+    url: string;
 }, {
-    uri: string;
-}>, import("zod").ZodObject<{
-    connectionString: import("zod").ZodString;
-}, "strip", import("zod").ZodTypeAny, {
-    connectionString: string;
-}, {
-    connectionString: string;
+    url: string;
 }>]>;
 export type MysqlCredentials = TypeOf<typeof mysqlCredentials>;
 export declare const printCliConnectionIssues: (options: any) => void;

package/cli/validations/outputs.d.ts

@@ -4,6 +4,7 @@ export declare const withStyle: {
     errorWarning: (str: string) => string;
     fullWarning: (str: string) => string;
     suggestion: (str: string) => string;
+    info: (str: string) => string;
 };
 export declare const outputs: {
     studio: {
@@ -15,12 +16,11 @@ export declare const outputs: {
     common: {
         ambiguousParams: (command: string) => string;
         schema: (command: string) => string;
-        schemaConfig: (command: string) => string;
     };
     postgres: {
         connection: {
-            driver: () => string;
             required: () => string;
+            awsDataApi: () => void;
         };
     };
     mysql: {

package/cli/validations/pg.d.ts

@@ -21,11 +21,26 @@ export declare const postgresCredentials: import("zod").ZodUnion<[import("zod").
     password?: string | undefined;
     ssl?: boolean | undefined;
 }>, import("zod").ZodObject<{
-    connectionString: import("zod").ZodString;
+    url: import("zod").ZodString;
 }, "strip", import("zod").ZodTypeAny, {
-    connectionString: string;
+    url: string;
 }, {
-    connectionString: string;
+    url: string;
+}>, import("zod").ZodObject<{
+    driver: import("zod").ZodLiteral<"aws-data-api">;
+    database: import("zod").ZodString;
+    secretArn: import("zod").ZodString;
+    resourceArn: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    database: string;
+    driver: "aws-data-api";
+    secretArn: string;
+    resourceArn: string;
+}, {
+    database: string;
+    driver: "aws-data-api";
+    secretArn: string;
+    resourceArn: string;
 }>]>;
 export type PostgresCredentials = TypeOf<typeof postgresCredentials>;
 export declare const printConfigConnectionIssues: (options: Record<string, unknown>) => void;