drizzle-kit 0.20.17-cab52ad → 0.20.17-d71f2ee

package/cli/commands/utils.d.ts

@@ -0,0 +1,180 @@
+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 { CliCheckConfig, CliConfigGenerate } from "../validations/cli";
+export declare const safeRegister: () => Promise<{
+    unregister: () => void;
+}>;
+export type GenerateConfig = {
+    dialect: Dialect;
+    schema: string | string[];
+    out: string;
+    breakpoints: boolean;
+    name?: string;
+    custom: boolean;
+    bundle: boolean;
+};
+export declare const prepareGenerateConfig: (options: CliConfigGenerate) => Promise<GenerateConfig>;
+export declare const flattenDatabaseCredentials: (config: any) => any;
+export declare const preparePushConfig: (options: Record<string, unknown>) => Promise<({
+    dialect: "mysql";
+    credentials: MysqlCredentials;
+} | {
+    dialect: "postgresql";
+    credentials: PostgresCredentials;
+} | {
+    dialect: "sqlite";
+    credentials: SqliteCredentials;
+}) & {
+    schemaPath: string | string[];
+    verbose: boolean;
+    strict: boolean;
+    tablesFilter: string[];
+    schemasFilter: string[];
+}>;
+export declare const preparePullConfig: (options: Record<string, unknown>) => Promise<({
+    dialect: "mysql";
+    credentials: MysqlCredentials;
+} | {
+    dialect: "postgresql";
+    credentials: PostgresCredentials;
+} | {
+    dialect: "sqlite";
+    credentials: SqliteCredentials;
+}) & {
+    out: string;
+    breakpoints: boolean;
+    casing: Casing;
+    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;
+    } | {
+        driver: "aws-data-api";
+        database: string;
+        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: "mysql" | "postgresql" | "sqlite";
+    out: string;
+    migrations?: {
+        schema?: string | undefined;
+        table?: string | undefined;
+    } | undefined;
+}, {
+    dialect: "mysql" | "postgresql" | "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;
+    } | {
+        driver: "aws-data-api";
+        database: string;
+        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;
+}>;
+export declare const drizzleConfigFromFile: (configPath?: string) => Promise<CliConfig>;
+export declare const readDrizzleConfig: (configPath?: string) => Promise<any>;

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/selector-ui.d.ts

@@ -0,0 +1,13 @@
+import { Prompt } from "hanji";
+export declare class Select extends Prompt<{
+    index: number;
+    value: string;
+}> {
+    private readonly data;
+    constructor(items: string[]);
+    render(status: "idle" | "submitted" | "aborted"): string;
+    result(): {
+        index: number;
+        value: string;
+    };
+}

package/cli/utils.d.ts

@@ -0,0 +1,13 @@
+export declare const assertExists: (it?: any) => void;
+export declare const assertStudioNodeVersion: () => void;
+export declare const checkPackage: (it: string) => Promise<boolean>;
+export declare const assertPackages: (...pkgs: string[]) => Promise<void>;
+export declare const assertEitherPackage: (...pkgs: string[]) => Promise<string[]>;
+export declare const assertOrmCoreVersion: () => Promise<void>;
+export declare const ormCoreVersions: () => Promise<{
+    compatibilityVersion: number;
+    npmVersion: string;
+} | {
+    compatibilityVersion?: undefined;
+    npmVersion?: undefined;
+}>;

package/cli/validations/cli.d.ts

@@ -0,0 +1,169 @@
+import { TypeOf } from "zod";
+export declare const cliConfigGenerate: import("zod").ZodObject<{
+    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>;
+    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, {
+    custom: boolean;
+    out: string;
+    breakpoints: boolean;
+    name?: string | undefined;
+    schema?: string | string[] | undefined;
+    dialect?: "mysql" | "postgresql" | "sqlite" | undefined;
+    config?: string | undefined;
+}, {
+    name?: string | undefined;
+    custom?: boolean | undefined;
+    schema?: string | string[] | undefined;
+    dialect?: "mysql" | "postgresql" | "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<["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">]>>;
+    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>;
+    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>;
+    authToken: import("zod").ZodOptional<import("zod").ZodString>;
+    verbose: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, "strip", import("zod").ZodTypeAny, {
+    dialect: "mysql" | "postgresql" | "sqlite";
+    schemaFilter: string | string[];
+    strict?: boolean | undefined;
+    schema?: string | string[] | undefined;
+    url?: string | undefined;
+    driver?: 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;
+    ssl?: string | undefined;
+    authToken?: string | undefined;
+}, {
+    dialect: "mysql" | "postgresql" | "sqlite";
+    strict?: boolean | undefined;
+    schema?: string | string[] | undefined;
+    url?: string | undefined;
+    driver?: string | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: 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;
+    ssl?: string | undefined;
+    authToken?: string | 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<["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>>;
+}, "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<["postgresql", "mysql", "sqlite"]>>;
+    out: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    dialect?: "mysql" | "postgresql" | "sqlite" | undefined;
+    out?: string | undefined;
+}, {
+    dialect?: "mysql" | "postgresql" | "sqlite" | undefined;
+    out?: string | undefined;
+}>;
+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<["postgresql", "mysql", "sqlite"]>>;
+    out: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    dialect?: "mysql" | "postgresql" | "sqlite" | undefined;
+    out?: string | undefined;
+}, {
+    dialect?: "mysql" | "postgresql" | "sqlite" | undefined;
+    out?: string | undefined;
+}>>;
+export type CliCheckConfig = TypeOf<typeof cliConfigCheck>;

package/cli/validations/common.d.ts

@@ -0,0 +1,214 @@
+import { TypeOf } from "zod";
+export type Commands = "introspect" | "generate" | "check" | "up" | "drop" | "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
+ * @param inputWhitelist - whitelist some cli options that can be used together with config option
+ * @returns true if there was a collision, false if everything is valid
+ */
+export declare const assertCollisions: (options: Record<string, unknown>, command: Commands, inputWhitelist?: string[]) => "config" | "cli";
+export declare const sqliteDriver: import("zod").ZodUnion<[import("zod").ZodLiteral<"better-sqlite">, import("zod").ZodLiteral<"turso">, import("zod").ZodLiteral<"libsql">, import("zod").ZodLiteral<"d1">, import("zod").ZodLiteral<"expo">]>;
+export declare const postgresDriver: import("zod").ZodLiteral<"aws-data-api">;
+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<"aws-data-api">, import("zod").ZodLiteral<"mysql2">]>;
+export declare const configCommonSchema: import("zod").ZodObject<{
+    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>;
+    driver: import("zod").ZodOptional<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<"aws-data-api">, import("zod").ZodLiteral<"mysql2">]>>;
+    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">]>>;
+}, "strip", import("zod").ZodTypeAny, {
+    schema: string | string[];
+    dialect: "mysql" | "postgresql" | "sqlite";
+    breakpoints: boolean;
+    schemaFilter: string | string[];
+    out?: string | undefined;
+    driver?: "better-sqlite" | "turso" | "libsql" | "d1" | "expo" | "aws-data-api" | "mysql2" | undefined;
+    tablesFilter?: string | string[] | undefined;
+}, {
+    schema: string | string[];
+    dialect: "mysql" | "postgresql" | "sqlite";
+    out?: string | undefined;
+    breakpoints?: boolean | undefined;
+    driver?: "better-sqlite" | "turso" | "libsql" | "d1" | "expo" | "aws-data-api" | "mysql2" | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: string | string[] | undefined;
+}>;
+export declare const casing: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodLiteral<"camel">, import("zod").ZodLiteral<"preserve">]>>;
+export declare const introspectParams: import("zod").ZodObject<{
+    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>>;
+    breakpoints: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    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">]>>;
+    introspect: import("zod").ZodDefault<import("zod").ZodObject<{
+        casing: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodLiteral<"camel">, import("zod").ZodLiteral<"preserve">]>>;
+    }, "strip", import("zod").ZodTypeAny, {
+        casing: "camel" | "preserve";
+    }, {
+        casing?: "camel" | "preserve" | undefined;
+    }>>;
+}, "strip", import("zod").ZodTypeAny, {
+    introspect: {
+        casing: "camel" | "preserve";
+    };
+    out: string;
+    breakpoints: boolean;
+    schemaFilter: string | string[];
+    schema?: string | string[] | undefined;
+    tablesFilter?: string | string[] | undefined;
+}, {
+    schema?: string | string[] | undefined;
+    introspect?: {
+        casing?: "camel" | "preserve" | undefined;
+    } | undefined;
+    out?: string | undefined;
+    breakpoints?: boolean | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: string | string[] | undefined;
+}>;
+export type IntrospectParams = TypeOf<typeof introspectParams>;
+export type Casing = TypeOf<typeof casing>;
+export declare const configIntrospectCliSchema: import("zod").ZodObject<{
+    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>>;
+    breakpoints: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    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">]>>;
+    introspectCasing: import("zod").ZodDefault<import("zod").ZodUnion<[import("zod").ZodLiteral<"camel">, import("zod").ZodLiteral<"preserve">]>>;
+}, "strip", import("zod").ZodTypeAny, {
+    out: string;
+    breakpoints: boolean;
+    schemaFilter: string | string[];
+    introspectCasing: "camel" | "preserve";
+    schema?: string | string[] | undefined;
+    tablesFilter?: string | string[] | undefined;
+}, {
+    schema?: string | string[] | undefined;
+    out?: string | undefined;
+    breakpoints?: boolean | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: string | string[] | undefined;
+    introspectCasing?: "camel" | "preserve" | undefined;
+}>;
+export declare const configGenerateSchema: import("zod").ZodObject<{
+    schema: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">]>;
+    out: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
+    breakpoints: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strip", import("zod").ZodTypeAny, {
+    schema: string | string[];
+    out: string;
+    breakpoints: boolean;
+}, {
+    schema: string | string[];
+    out?: string | undefined;
+    breakpoints?: boolean | undefined;
+}>;
+export type GenerateSchema = TypeOf<typeof configGenerateSchema>;
+export declare const configPushSchema: import("zod").ZodObject<{
+    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">]>>;
+    verbose: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    strict: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    out: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strip", import("zod").ZodTypeAny, {
+    strict: boolean;
+    schema: string | string[];
+    dialect: "mysql" | "postgresql" | "sqlite";
+    schemaFilter: string | string[];
+    verbose: boolean;
+    out?: string | undefined;
+    tablesFilter?: string | string[] | undefined;
+}, {
+    schema: string | string[];
+    dialect: "mysql" | "postgresql" | "sqlite";
+    strict?: boolean | undefined;
+    out?: string | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: string | string[] | undefined;
+    verbose?: boolean | undefined;
+}>;
+export declare const mysqlConnectionSchema: import("zod").ZodUnion<[import("zod").ZodObject<{
+    host: import("zod").ZodString;
+    port: import("zod").ZodOptional<import("zod").ZodNumber>;
+    user: import("zod").ZodDefault<import("zod").ZodString>;
+    password: import("zod").ZodOptional<import("zod").ZodString>;
+    database: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    host: string;
+    user: string;
+    database: string;
+    port?: number | undefined;
+    password?: string | undefined;
+}, {
+    host: string;
+    database: string;
+    port?: number | undefined;
+    user?: string | undefined;
+    password?: string | undefined;
+}>, import("zod").ZodObject<{
+    connectionString: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    connectionString: string;
+}, {
+    connectionString: string;
+}>, import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>]>;
+export declare const mySqlCliConfigSchema: import("zod").ZodIntersection<import("zod").ZodObject<{
+    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>;
+    driver: import("zod").ZodOptional<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<"aws-data-api">, import("zod").ZodLiteral<"mysql2">]>>;
+    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">]>>;
+}, "strip", import("zod").ZodTypeAny, {
+    schema: string | string[];
+    dialect: "mysql" | "postgresql" | "sqlite";
+    breakpoints: boolean;
+    schemaFilter: string | string[];
+    out?: string | undefined;
+    driver?: "better-sqlite" | "turso" | "libsql" | "d1" | "expo" | "aws-data-api" | "mysql2" | undefined;
+    tablesFilter?: string | string[] | undefined;
+}, {
+    schema: string | string[];
+    dialect: "mysql" | "postgresql" | "sqlite";
+    out?: string | undefined;
+    breakpoints?: boolean | undefined;
+    driver?: "better-sqlite" | "turso" | "libsql" | "d1" | "expo" | "aws-data-api" | "mysql2" | undefined;
+    tablesFilter?: string | string[] | undefined;
+    schemaFilter?: string | string[] | undefined;
+}>, import("zod").ZodUnion<[import("zod").ZodObject<{
+    host: import("zod").ZodString;
+    port: import("zod").ZodOptional<import("zod").ZodNumber>;
+    user: import("zod").ZodDefault<import("zod").ZodString>;
+    password: import("zod").ZodOptional<import("zod").ZodString>;
+    database: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    host: string;
+    user: string;
+    database: string;
+    port?: number | undefined;
+    password?: string | undefined;
+}, {
+    host: string;
+    database: string;
+    port?: number | undefined;
+    user?: string | undefined;
+    password?: string | undefined;
+}>, import("zod").ZodObject<{
+    connectionString: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    connectionString: string;
+}, {
+    connectionString: string;
+}>, import("zod").ZodObject<{}, "strip", import("zod").ZodTypeAny, {}, {}>]>>;
+export type MySqlCliConfig = TypeOf<typeof mySqlCliConfigSchema>;
+export type CliConfig = MySqlCliConfig;
+export type SqliteDriver = TypeOf<typeof sqliteDriver>;
+export type MysqlDriver = TypeOf<typeof mysqlDriver>;
+export type PostgresDriver = TypeOf<typeof postgresDriver>;
+export type Driver = TypeOf<typeof driver>;

package/cli/validations/mysql.d.ts

@@ -0,0 +1,29 @@
+import { TypeOf } from "zod";
+export declare const mysqlCredentials: import("zod").ZodUnion<[import("zod").ZodObject<{
+    host: import("zod").ZodString;
+    port: import("zod").ZodOptional<import("zod").ZodNumber>;
+    user: import("zod").ZodDefault<import("zod").ZodString>;
+    password: import("zod").ZodOptional<import("zod").ZodString>;
+    database: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    host: string;
+    user: string;
+    database: string;
+    port?: number | undefined;
+    password?: string | undefined;
+}, {
+    host: string;
+    database: string;
+    port?: number | undefined;
+    user?: string | undefined;
+    password?: string | undefined;
+}>, import("zod").ZodObject<{
+    url: import("zod").ZodString;
+}, "strip", import("zod").ZodTypeAny, {
+    url: string;
+}, {
+    url: string;
+}>]>;
+export type MysqlCredentials = TypeOf<typeof mysqlCredentials>;
+export declare const printCliConnectionIssues: (options: any) => void;
+export declare const printConfigConnectionIssues: (options: Record<string, unknown>) => void;